@geode/opengeodeweb-front 10.6.0 → 10.6.1-rc.2

package/.oxlintrc.json

@@ -38,7 +38,8 @@
           "id",
           "ID",
           "fs",
-          "os"
+          "os",
+          "_"
         ],
         "min": 3
       }
@@ -53,6 +54,7 @@
     "oxc/no-optional-chaining": "off",
     "node/no-process-env": "off",
     "no-continue": "off",
+    "vitest/require-hook": "off",
     "import/unambiguous": "off",
     "max-params": ["warn", { "max": 4 }],
     "import/no-nodejs-modules": "off",

package/app/stores/app.js

@@ -1,5 +1,5 @@
-import { upload_file } from "@ogw_internal/utils/upload_file.js"
 import { api_fetch } from "@ogw_internal/utils/api_fetch.js"
+import { upload_file } from "@ogw_internal/utils/upload_file.js"
 
 export const useAppStore = defineStore("app", () => {
   const stores = []

package/app/stores/geode.js

@@ -2,10 +2,10 @@ import { Status } from "@ogw_front/utils/status"
 import { api_fetch } from "@ogw_internal/utils/api_fetch"
 import { appMode } from "@ogw_front/utils/app_mode"
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import { upload_file } from "@ogw_internal/utils/upload_file.js"
+import { useAppStore } from "@ogw_front/stores/app"
 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
@@ -132,7 +132,7 @@ export const useGeodeStore = defineStore("geode", {
               "[GEODE] Request completed:",
               schema.$id,
               "in",
-              (Date.now() - start) / 1_000,
+              (Date.now() - start) / MILLISECONDS_IN_SECOND,
               "s",
             )
             if (callbacks.response_function) {

package/app/stores/infra.js

@@ -1,7 +1,7 @@
 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 { useLambdaStore } from "@ogw_front/stores/lambda"
 
 import { registerRunningExtensions } from "@ogw_front/utils/extension"
 
@@ -50,18 +50,15 @@ export const useInfraStore = defineStore("infra", {
         "[INFRA] Registered microservices:",
         this.microservices.map((store) => store.$id),
       )
-
       if (this.status === Status.CREATED) {
         return
       }
-
       return navigator.locks.request("infra.create_backend", async () => {
         this.status = Status.CREATING
         if (this.status === Status.CREATED) {
           return
         }
         console.log("[INFRA] Lock granted for create_backend")
-
         if (this.app_mode === appMode.CLOUD) {
           console.log("[INFRA] CLOUD mode - Launching lambda...")
           const lambdaStore = useLambdaStore()
@@ -71,26 +68,22 @@ export const useInfraStore = defineStore("infra", {
           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 launch_promises = microservices_with_launch.map((store) =>
             store.launch({ projectFolderPath: appStore.projectFolderPath }),
           )
-          await Promise.all(launch_promises, registerRunningExtensions())
+          launch_promises.push(registerRunningExtensions())
+          await Promise.all(launch_promises)
         }
-
         this.status = Status.CREATED
         console.log("[INFRA] Backend created successfully")
         return this.create_connection()

package/app/stores/viewer.js

@@ -2,10 +2,11 @@
 import vtkWSLinkClient, {
   newInstance,
 } from "@kitware/vtk.js/IO/Core/WSLinkClient"
-// oxlint-disable-next-line id-length
 import _ from "lodash"
 // oxlint-disable-next-line no-unassigned-import
 import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry"
+import SmartConnect from "wslink/src/SmartConnect"
+import { connectImageStream } from "@kitware/vtk.js/Rendering/Misc/RemoteView"
 import schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 import { useRuntimeConfig } from "nuxt/app"
 
@@ -22,6 +23,7 @@ const request_timeout = MS_PER_SECOND * SECONDS_PER_REQUEST
 
 export const useViewerStore = defineStore(
   "viewer",
+  // oxlint-disable-next-line max-lines-per-function max-statements
   () => {
     const infraStore = useInfraStore()
     const default_local_port = ref("1234")
@@ -76,7 +78,7 @@ export const useViewerStore = defineStore(
       picking_mode.value = false
     }
 
-    async function ws_connect() {
+    function ws_connect() {
       if (status.value === Status.CONNECTED) {
         return
       }
@@ -87,46 +89,31 @@ export const useViewerStore = defineStore(
         try {
           console.log("VIEWER LOCK GRANTED !", lock)
           status.value = Status.CONNECTING
-          const { default: SmartConnect } =
-            await import("wslink/src/SmartConnect")
           vtkWSLinkClient.setSmartConnectClass(SmartConnect)
 
-          const config_obj = { application: "Viewer" }
-          config_obj.sessionURL = base_url.value
-
-          if (status.value === Status.CONNECTED && client.value.isConnected()) {
-            client.value.disconnect(-1)
-            status.value = Status.NOT_CONNECTED
-          }
-          let clientToConnect = client.value
-          if (_.isEmpty(clientToConnect)) {
-            clientToConnect = newInstance()
+          if (_.isEmpty(client.value)) {
+            client.value = newInstance()
           }
 
-          // Connect to busy store
-          clientToConnect.onBusyChange((count) => {
+          client.value.onBusyChange((count) => {
             buzy.value = count
           })
-          clientToConnect.beginBusy()
-
-          // Error
-          clientToConnect.onConnectionError((httpReq) => {
+          client.value.onConnectionError((httpReq) => {
             const message = httpReq?.response?.error || `Connection error`
             console.error(message)
           })
-
-          // Close
-          clientToConnect.onConnectionClose((httpReq) => {
+          client.value.onConnectionClose((httpReq) => {
             const message = httpReq?.response?.error || `Connection close`
             console.error(message)
           })
 
-          // Connect
-          const { connectImageStream } =
-            await import("@kitware/vtk.js/Rendering/Misc/RemoteView")
-          client.value = await clientToConnect.connect(config_obj)
+          client.value.beginBusy()
+          await client.value.connect({
+            application: "Viewer",
+            sessionURL: base_url.value,
+          })
           connectImageStream(client.value.getConnection().getSession())
-          clientToConnect.endBusy()
+          client.value.endBusy()
           await request(
             schemas.opengeodeweb_viewer.viewer.reset_visualization,
             {},
@@ -135,7 +122,7 @@ export const useViewerStore = defineStore(
           )
           status.value = Status.CONNECTED
         } catch (error) {
-          console.error("error", error)
+          console.error("ws_connect error", error)
           status.value = Status.NOT_CONNECTED
           throw error
         }
@@ -214,7 +201,7 @@ export const useViewerStore = defineStore(
               "[VIEWER] Request completed:",
               schema.$id,
               "in",
-              (Date.now() - start) / 1_000,
+              (Date.now() - start) / MS_PER_SECOND,
               "s",
             )
             if (callbacks.response_function) {

package/app/utils/extension.js

@@ -18,33 +18,35 @@ async function registerRunningExtensions() {
   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
+  return Promise.all(
+    extensionsArray.map(async (extension) => {
+      const { name, version, frontendContent, port } = extension
+      const blob = new Blob([frontendContent], {
+        type: "application/javascript",
       })
-      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,
-    }
-  }
+      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) {
@@ -79,9 +81,9 @@ async function uploadExtension(file) {
   await appStore.upload(file)
 }
 
-async function runExtensions() {
+function runExtensions() {
   const appStore = useAppStore()
-  const projectFolderPath = appStore.projectFolderPath
+  const { projectFolderPath } = appStore
   const { PROJECT: projectName } = useRuntimeConfig().public
   const params = { projectFolderPath, projectName }
 

package/app/utils/file_import_workflow.js

@@ -1,3 +1,4 @@
+// oxlint-disable promise/prefer-await-to-then
 // Third party imports
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 

package/app/utils/local/microservices.js

@@ -5,17 +5,17 @@ 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 pTimeout from "p-timeout"
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" }
 
 // Local imports
+import { commandExistsSync, waitForReady } from "./scripts.js"
 import {
   deleteFolderRecursive,
-  executablePath,
   executableName,
+  executablePath,
 } from "./path.js"
-import { commandExistsSync, waitForReady } from "./scripts.js"
 
 const DEFAULT_TIMEOUT_SECONDS = 30
 const MILLISECONDS_PER_SECOND = 1000
@@ -143,6 +143,7 @@ function killWebsocketMicroservice(microservice) {
   const failMessage = `Failed to kill ${microservice.name}`
   const successMessage = `Disconnected from ${microservice.name} WebSocket server`
   function do_kill() {
+    // oxlint-disable-next-line promise/avoid-new
     return new Promise((resolve) => {
       const socket = new WebSocket(microservice.url)
       socket.on("open", () => {
@@ -213,11 +214,11 @@ function projectMicroservices(projectFolderPath) {
     const microservicesMetadatas = { microservices: [] }
     fs.writeFileSync(
       filePath,
-      JSON.stringify(microservicesMetadatas, null, 2),
-      "utf-8",
+      JSON.stringify(microservicesMetadatas, undefined, 2),
+      "utf8",
     )
   }
-  const content = JSON.parse(fs.readFileSync(filePath, "utf-8"))
+  const content = JSON.parse(fs.readFileSync(filePath, "utf8"))
   return content.microservices
 }
 
@@ -236,7 +237,8 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
   if (serviceObj.type === "back") {
     const schema = back_schemas.opengeodeweb_back.kill
     serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`
-    serviceObj.method = schema.methods[0]
+    const [method] = schema.methods
+    serviceObj.method = method
   } else if (serviceObj.type === "viewer") {
     serviceObj.url = `ws://localhost:${serviceObj.port}/ws`
   }
@@ -244,7 +246,7 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
   microservices.push(serviceObj)
   fs.writeFileSync(
     microservicesMetadatasPath(projectFolderPath),
-    JSON.stringify({ microservices }, null, 2),
+    JSON.stringify({ microservices }, undefined, 2),
   )
 }
 

package/app/utils/local/scripts.js

@@ -1,7 +1,7 @@
 // Node imports
-import { on } from "node:events"
 import child_process from "node:child_process"
 import fs from "node:fs"
+import { on } from "node:events"
 import path from "node:path"
 
 function commandExistsSync(execName) {

package/app/utils/server.js

@@ -16,22 +16,23 @@ async function unzipFile(
     await fs.promises.mkdir(outputDir, { recursive: true })
     const promises = []
 
-    zip.forEach((relativePath, zipEntry) => {
+    for (const [relativePath, zipEntry] of Object.entries(zip.files)) {
       const outputPath = path.join(outputDir, relativePath)
 
       if (zipEntry.dir) {
         promises.push(fs.promises.mkdir(outputPath, { recursive: true }))
       } else {
         promises.push(
-          zipEntry.async("nodebuffer").then(async (content) => {
+          (async () => {
+            const content = await zipEntry.async("nodebuffer")
             await fs.promises.mkdir(path.dirname(outputPath), {
               recursive: true,
             })
             await fs.promises.writeFile(outputPath, content)
-          }),
+          })(),
         )
       }
-    })
+    }
 
     await Promise.all(promises)
     console.log("Extraction complete!")

package/internal/utils/api_fetch.js

@@ -1,4 +1,3 @@
-// oxlint-disable-next-line id-length
 import _ from "lodash"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
 import { validate_schema } from "@ogw_front/utils/validate_schema"

package/microservices.json

@@ -0,0 +1,3 @@
+{
+  "microservices": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.6.0",
+  "version": "10.6.1-rc.2",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -31,15 +31,15 @@
     "build": ""
   },
   "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.11.3",
     "@types/node": "22.15.3",
     "@vueuse/components": "13.1.0",
     "@vueuse/nuxt": "13.1.0",
-    "@vueuse/rxjs": "^14.1.0",
+    "@vueuse/rxjs": "14.1.0",
     "ajv": "8.17.1",
     "busboy": "1.6.0",
     "conf": "15.1.0",

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

@@ -7,5 +7,6 @@ import { defineEventHandler } from "h3"
 
 export default defineEventHandler(() => {
   console.log("Killing node server process")
+  // oxlint-disable-next-line no-process-exit
   process.exit()
 })

package/server/api/extensions/run.post.js

@@ -6,12 +6,12 @@ import path from "node:path"
 import { createError, defineEventHandler, readBody } from "h3"
 
 // Local imports
-import { extensionsConf } from "@geode/opengeodeweb-front/app/utils/config.js"
-import { unzipFile } from "@geode/opengeodeweb-front/app/utils/server.js"
 import {
   addMicroserviceMetadatas,
   runBack,
 } from "@geode/opengeodeweb-front/app/utils/local/microservices.js"
+import { extensionsConf } from "@geode/opengeodeweb-front/app/utils/config.js"
+import { unzipFile } from "@geode/opengeodeweb-front/app/utils/server.js"
 
 const CODE_200 = 200
 
@@ -21,68 +21,69 @@ export default defineEventHandler(async (event) => {
     const { projectFolderPath, projectName } = body
     const extensionsConfig = extensionsConf(projectName)
 
-    const extensionsArray = []
+    const extensionsArray = await Promise.all(
+      Object.keys(extensionsConfig).map(async (extensionID) => {
+        const extensionPath = extensionsConfig[extensionID].path
+        const unzippedExtensionPath = await unzipFile(
+          extensionPath,
+          path.join(projectFolderPath, "extensions"),
+        )
+        const metadataPath = path.join(unzippedExtensionPath, "metadata.json")
+        const metadataContent = await fs.promises.readFile(metadataPath, "utf8")
 
-    for (const extensionID of Object.keys(extensionsConfig)) {
-      const extensionPath = extensionsConfig[extensionID].path
-      const unzippedExtensionPath = await unzipFile(
-        extensionPath,
-        path.join(projectFolderPath, "extensions"),
-      )
-      const metadataPath = path.join(unzippedExtensionPath, "metadata.json")
-      const metadataContent = await fs.promises.readFile(metadataPath, "utf-8")
+        if (!metadataContent) {
+          throw createError({
+            statusCode: 400,
+            statusMessage: "Invalid extension file: missing metadata.json",
+          })
+        }
+        const metadata = JSON.parse(metadataContent)
+        console.log("runExtensions", { metadata })
 
-      if (!metadataContent) {
-        throw createError({
-          statusCode: 400,
-          statusMessage: "Invalid extension file: missing metadata.json",
-        })
-      }
-      const metadata = JSON.parse(metadataContent)
-      console.log("runExtensions", { metadata })
+        const { id, name, version, backendExecutable, frontendFile } = metadata
+        console.log("runExtensions", { id, name, version, backendExecutable })
 
-      const { id, name, version, backendExecutable, frontendFile } = metadata
-      console.log("runExtensions", { id, name, version, backendExecutable })
+        if (!frontendFile) {
+          throw createError({
+            statusCode: 400,
+            statusMessage:
+              "Invalid extension file: missing frontend JavaScript",
+          })
+        }
+        if (!backendExecutable) {
+          throw createError({
+            statusCode: 400,
+            statusMessage: "Invalid extension file: missing backend executable",
+          })
+        }
 
-      if (!frontendFile) {
-        throw createError({
-          statusCode: 400,
-          statusMessage: "Invalid extension file: missing frontend JavaScript",
+        const frontendFilePath = path.join(unzippedExtensionPath, frontendFile)
+        const frontendContent = await fs.promises.readFile(
+          frontendFilePath,
+          "utf8",
+        )
+        const backendExecutablePath = path.join(
+          unzippedExtensionPath,
+          backendExecutable,
+        )
+        fs.chmodSync(backendExecutablePath, "755")
+        const port = await runBack(backendExecutable, backendExecutablePath, {
+          projectFolderPath,
         })
-      }
-      if (!backendExecutable) {
-        throw createError({
-          statusCode: 400,
-          statusMessage: "Invalid extension file: missing backend executable",
+        await addMicroserviceMetadatas(projectFolderPath, {
+          type: "back",
+          name,
+          port,
         })
-      }
-
-      const frontendFilePath = path.join(unzippedExtensionPath, frontendFile)
-      const frontendContent = await fs.promises.readFile(
-        frontendFilePath,
-        "utf-8",
-      )
-      const backendExecutablePath = path.join(
-        unzippedExtensionPath,
-        backendExecutable,
-      )
-      await fs.chmodSync(backendExecutablePath, "755")
-      const port = await runBack(backendExecutable, backendExecutablePath, {
-        projectFolderPath,
-      })
-      extensionsArray.push({
-        id,
-        name,
-        version,
-        frontendContent,
-        port,
-      })
-      await addMicroserviceMetadatas(projectFolderPath, {
-        type: "back",
-        name,
-        port,
-      })
-    }
+        return {
+          id,
+          name,
+          version,
+          frontendContent,
+          port,
+        }
+      }),
+    )
 
     return {
       statusCode: CODE_200,

package/server/api/extensions/upload.put.js

@@ -1,27 +1,28 @@
 // Node imports
+import { finished, pipeline } from "node:stream/promises"
+import { Readable } from "node:stream"
 import fs from "node:fs"
 import path from "node:path"
-import { Readable } from "node:stream"
 
 // Third party imports
-import busboy from "busboy"
 import {
   createError,
   defineEventHandler,
   getRequestHeaders,
   getRequestWebStream,
 } from "h3"
-
-import sanitize from "sanitize-filename"
 import StreamZip from "node-stream-zip"
+import busboy from "busboy"
+import sanitize from "sanitize-filename"
 
 // Local imports
 import {
-  confFolderPath,
   addExtensionToConf,
+  confFolderPath,
 } from "@geode/opengeodeweb-front/app/utils/config.js"
 
 const CODE_201 = 201
+const FILE_SIZE_LIMIT = 107_374_182 // 100 MB
 
 export default defineEventHandler(async (event) => {
   const projectName = "vease"
@@ -30,53 +31,51 @@ export default defineEventHandler(async (event) => {
 
   const configFolderPath = confFolderPath(projectName)
 
-  await new Promise((resolve, reject) => {
-    const bb = busboy({
-      headers: getRequestHeaders(event),
-      limits: {
-        fileSize: 1024 * 1024 * 1024 * 0.1, // 100 MB
-        files: 1,
-      },
-    })
-
-    bb.on("file", (fieldname, fileStream, info) => {
-      if (fieldname !== "file") {
-        fileStream.resume() // drain & ignore unwanted fields
-        return
-      }
-
-      const safeFilename = sanitize(info.filename)
-      const targetPath = path.join(configFolderPath, safeFilename)
-
-      const writePromise = new Promise((res, rej) => {
-        const writeStream = fs.createWriteStream(targetPath)
-
-        fileStream
-          .pipe(writeStream)
-          .on("finish", () => {
-            savedFiles.push(targetPath)
-            console.log("File written:", targetPath)
-            res()
-          })
-          .on("error", rej)
-      })
+  const busboyInstance = busboy({
+    headers: getRequestHeaders(event),
+    limits: {
+      fileSize: FILE_SIZE_LIMIT,
+      files: 1,
+    },
+  })
 
-      writePromises.push(writePromise)
-      fileStream.on("limit", () => reject(new Error("File too large")))
-    })
+  busboyInstance.on("file", (fieldname, fileStream, info) => {
+    if (fieldname !== "file") {
+      // Drain & ignore unwanted fields
+      fileStream.resume()
+      return
+    }
+
+    const safeFilename = sanitize(info.filename)
+    const targetPath = path.join(configFolderPath, safeFilename)
+
+    const writePromise = (async () => {
+      const writeStream = fs.createWriteStream(targetPath)
+      await pipeline(fileStream, writeStream)
+      savedFiles.push(targetPath)
+      console.log("File written:", targetPath)
+    })()
+
+    writePromises.push(writePromise)
+    fileStream.on("limit", () =>
+      busboyInstance.destroy(new Error("File too large")),
+    )
+  })
 
-    bb.on("field", (name, value) => {
-      console.log(`Field ${name}: ${value}`)
-    })
+  busboyInstance.on("field", (name, value) => {
+    console.log(`Field ${name}: ${value}`)
+  })
 
-    bb.on("close", resolve)
-    bb.on("error", reject)
-    bb.on("filesLimit", () => reject(new Error("Too many files")))
-    bb.on("partsLimit", () => reject(new Error("Too many parts")))
+  busboyInstance.on("filesLimit", () =>
+    busboyInstance.destroy(new Error("Too many files")),
+  )
+  busboyInstance.on("partsLimit", () =>
+    busboyInstance.destroy(new Error("Too many parts")),
+  )
 
-    const webStream = getRequestWebStream(event)
-    Readable.fromWeb(webStream).pipe(bb)
-  })
+  const webStream = getRequestWebStream(event)
+  Readable.fromWeb(webStream).pipe(busboyInstance)
+  await finished(busboyInstance)
 
   if (writePromises.length > 0) {
     await Promise.all(writePromises)
@@ -87,19 +86,22 @@ export default defineEventHandler(async (event) => {
     throw createError({ statusCode: 400, message: "No file received" })
   }
 
-  for (const file of savedFiles) {
-    const zip = new StreamZip.async({
-      file,
-      storeEntries: true,
-    })
-    const metadataJson = await zip.entryData("metadata.json")
-    const metadata = JSON.parse(metadataJson)
-    const { id } = metadata
-    await addExtensionToConf(projectName, {
-      extensionID: id,
-      extensionPath: file,
-    })
-  }
+  await Promise.all(
+    savedFiles.map(async (file) => {
+      const StreamZipAsync = StreamZip.async
+      const zip = new StreamZipAsync({
+        file,
+        storeEntries: true,
+      })
+      const metadataJson = await zip.entryData("metadata.json")
+      const metadata = JSON.parse(metadataJson)
+      const { id } = metadata
+      await addExtensionToConf(projectName, {
+        extensionID: id,
+        extensionPath: file,
+      })
+    }),
+  )
 
   return { statusCode: CODE_201 }
 })

package/tests/integration/setup.js

@@ -1,28 +1,28 @@
 // Node.js imports
-import path from "node:path"
 import { WebSocket } from "ws"
+import path from "node:path"
 
 // Third party imports
 import { afterAll, beforeAll, expect, vi } from "vitest"
 import { useRuntimeConfig } from "nuxt/app"
 
 // Local imports
-import {
-  createPath,
-  generateProjectFolderPath,
-} from "@ogw_front/utils/local/path"
 import {
   addMicroserviceMetadatas,
   runBack,
   runViewer,
 } from "@ogw_front/utils/local/microservices"
+import {
+  createPath,
+  generateProjectFolderPath,
+} from "@ogw_front/utils/local/path"
 import { Status } from "@ogw_front/utils/status"
 import { appMode } from "@ogw_front/utils/app_mode"
 import { importFile } from "@ogw_front/utils/file_import_workflow"
+import { setupActivePinia } from "@ogw_tests/utils"
 import { useGeodeStore } from "@ogw_front/stores/geode"
 import { useInfraStore } from "@ogw_front/stores/infra"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupActivePinia } from "@ogw_tests/utils"
 
 // Local constants
 const data_folder = path.join("tests", "integration", "data", "uploads")

package/tests/integration/stores/data_style/mesh/cells.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/mesh/edges.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 25_000

package/tests/integration/stores/data_style/mesh/index.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/mesh/points.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/mesh/polygons.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/mesh/polyhedra.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/model/blocks.nuxt.test.js

@@ -3,12 +3,12 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStore } from "@ogw_front/stores/data"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/model/corners.nuxt.test.js

@@ -3,12 +3,12 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStore } from "@ogw_front/stores/data"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/model/edges.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 25_000

package/tests/integration/stores/data_style/model/index.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/model/lines.nuxt.test.js

@@ -3,12 +3,12 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStore } from "@ogw_front/stores/data"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/model/points.nuxt.test.js

@@ -3,11 +3,11 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/data_style/model/surfaces.nuxt.test.js

@@ -3,12 +3,12 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
+import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 import { useDataStore } from "@ogw_front/stores/data"
 import { useDataStyleStore } from "@ogw_front/stores/data_style"
 import { useViewerStore } from "@ogw_front/stores/viewer"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
 
 // Local constants
 const INTERVAL_TIMEOUT = 20_000

package/tests/integration/stores/viewer.nuxt.test.js

@@ -5,11 +5,11 @@ import { afterEach, beforeEach, describe, expect, test } from "vitest"
 import opengeodeweb_viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { Status } from "@ogw_front/utils/status"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { cleanupBackend } from "@ogw_front/utils/local/microservices"
 import { runMicroservices } from "@ogw_tests/integration/setup"
 import { setupActivePinia } from "@ogw_tests/utils"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 const CONNECT_TIMEOUT = 25_000
 

package/tests/unit/stores/infra.nuxt.test.js

@@ -275,12 +275,7 @@ describe("Infra Store", () => {
     })
 
     describe("create_backend", () => {
-      // test("test without microservices", async () => {
-      //   const infraStore = useInfraStore()
-      //   infraStore.app_mode = appMode.BROWSER
-      //   await infraStore.create_backend()
-      //   expect(infraStore.status).toBe(Status.CREATED)
-      // })
+      // Test without microservices
       test("test with end-point", async () => {
         const infraStore = useInfraStore()
         const geodeStore = useGeodeStore()