@geode/opengeodeweb-front 10.6.2 → 10.6.3-rc.1

package/app/utils/extension.js

@@ -1,90 +1,90 @@
 // Node.js imports
 
 // Third party imports
-import _ from "lodash"
+import _ from "lodash";
 
 // Local imports
-import { useAppStore } from "@ogw_front/stores/app"
-import { useInfraStore } from "@ogw_front/stores/infra"
+import { useAppStore } from "@ogw_front/stores/app";
+import { useInfraStore } from "@ogw_front/stores/infra";
 
 async function importExtensionFile(file) {
-  await uploadExtension(file)
-  return registerRunningExtensions()
+  await uploadExtension(file);
+  return registerRunningExtensions();
 }
 
 async function registerRunningExtensions() {
-  const appStore = useAppStore()
-  const infraStore = useInfraStore()
-  const { extensionsArray } = await runExtensions()
+  const appStore = useAppStore();
+  const infraStore = useInfraStore();
+  const { extensionsArray } = await runExtensions();
 
   return Promise.all(
     extensionsArray.map(async (extension) => {
-      const { name, version, frontendContent, port } = extension
+      const { 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)
+      });
+      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()
+        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)
+          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 appStore = useAppStore();
+  console.log("[ExtensionManager] Unloading extension:", extensionId);
 
-  const extensionData = appStore.getExtension(extensionId)
+  const extensionData = appStore.getExtension(extensionId);
   if (!extensionData) {
-    console.warn("[ExtensionManager] Extension not found:", extensionId)
-    return false
+    console.warn("[ExtensionManager] Extension not found:", extensionId);
+    return false;
   }
 
   // Get the store if it exists
-  const storeFactory = extensionData.metadata?.store
+  const storeFactory = extensionData.metadata?.store;
   if (storeFactory) {
-    const store = storeFactory()
+    const store = storeFactory();
     // Stop the microservice if possible
     if (typeof store.kill === "function") {
-      await store.kill()
+      await store.kill();
     }
   }
 
   // Unload from AppStore
-  appStore.unloadExtension(extensionId)
+  appStore.unloadExtension(extensionId);
 
-  console.log("[ExtensionManager] Extension unloaded:", extensionId)
-  return true
+  console.log("[ExtensionManager] Extension unloaded:", extensionId);
+  return true;
 }
 
 async function uploadExtension(file) {
-  const appStore = useAppStore()
-  await appStore.upload(file)
+  const appStore = useAppStore();
+  await appStore.upload(file);
 }
 
 function runExtensions() {
-  const appStore = useAppStore()
-  const { projectFolderPath } = appStore
-  const { PROJECT: projectName } = useRuntimeConfig().public
-  const params = { projectFolderPath, projectName }
+  const appStore = useAppStore();
+  const { projectFolderPath } = appStore;
+  const { PROJECT: projectName } = useRuntimeConfig().public;
+  const params = { projectFolderPath, projectName };
 
   const schema = {
     $id: "/api/extensions/run",
@@ -96,9 +96,9 @@ function runExtensions() {
     },
     required: ["projectFolderPath", "projectName"],
     additionalProperties: false,
-  }
+  };
 
-  return appStore.request(schema, params)
+  return appStore.request(schema, params);
 }
 
 export {
@@ -107,4 +107,4 @@ export {
   uploadExtension,
   registerRunningExtensions,
   runExtensions,
-}
+};

package/app/utils/file_import_workflow.js

@@ -1,73 +1,62 @@
 // oxlint-disable promise/prefer-await-to-then
 // Third party imports
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
 
 // Local imports
-import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useGeodeStore } from "@ogw_front/stores/geode"
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
-import { useTreeviewStore } from "@ogw_front/stores/treeview"
+import { useDataStore } from "@ogw_front/stores/data";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useGeodeStore } from "@ogw_front/stores/geode";
+import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
+import { useTreeviewStore } from "@ogw_front/stores/treeview";
 
-const SECOND = 1000
+const SECOND = 1000;
 
 async function importWorkflow(files) {
-  console.log("importWorkflow", { files })
-  const start = Date.now()
-  const promise_array = []
+  console.log("importWorkflow", { files });
+  const start = Date.now();
+  const promise_array = [];
   for (const file of files) {
-    const { filename, geode_object_type } = file
-    console.log({ filename }, { geode_object_type })
-    promise_array.push(importFile(filename, geode_object_type))
+    const { filename, geode_object_type } = file;
+    console.log({ filename }, { geode_object_type });
+    promise_array.push(importFile(filename, geode_object_type));
   }
-  const results = await Promise.all(promise_array)
-  const hybridViewerStore = useHybridViewerStore()
-  hybridViewerStore.remoteRender()
-  console.log("importWorkflow completed in", (Date.now() - start) / SECOND)
-  return results
+  const results = await Promise.all(promise_array);
+  const hybridViewerStore = useHybridViewerStore();
+  hybridViewerStore.remoteRender();
+  console.log("importWorkflow completed in", (Date.now() - start) / SECOND);
+  return results;
 }
 
 function buildImportItemFromPayloadApi(value, geode_object_type) {
-  console.log("buildImportItemFromPayloadApi", { value, geode_object_type })
+  console.log("buildImportItemFromPayloadApi", { value, geode_object_type });
   return {
     ...value,
-  }
+  };
 }
 
 async function importItem(item) {
-  const dataStore = useDataStore()
-  const dataStyleStore = useDataStyleStore()
-  const hybridViewerStore = useHybridViewerStore()
-  const treeviewStore = useTreeviewStore()
-  const registerTask = dataStore.registerObject(item.id)
-  const addDataTask = dataStore.addItem(item)
+  const dataStore = useDataStore();
+  const dataStyleStore = useDataStyleStore();
+  const hybridViewerStore = useHybridViewerStore();
+  const treeviewStore = useTreeviewStore();
+  const registerTask = dataStore.registerObject(item.id);
+  const addDataTask = dataStore.addItem(item);
 
   const addDataComponentsTask =
-    item.viewer_type === "model"
-      ? dataStore.addComponents(item)
-      : Promise.resolve()
+    item.viewer_type === "model" ? dataStore.addComponents(item) : Promise.resolve();
   const addDataRelationsTask =
-    item.viewer_type === "model"
-      ? dataStore.addComponentRelations(item)
-      : Promise.resolve()
+    item.viewer_type === "model" ? dataStore.addComponentRelations(item) : Promise.resolve();
   const addTreeviewTask = treeviewStore.addItem(
     item.geode_object_type,
     item.name,
     item.id,
     item.viewer_type,
-  )
-  const addStyleTask = dataStyleStore.addDataStyle(
-    item.id,
-    item.geode_object_type,
-  )
-  const addViewerTask = addDataTask.then(() =>
-    hybridViewerStore.addItem(item.id),
-  )
-  const applyStyleTask = Promise.all([
-    registerTask,
-    addDataComponentsTask,
-    addStyleTask,
-  ]).then(() => dataStyleStore.applyDefaultStyle(item.id))
+  );
+  const addStyleTask = dataStyleStore.addDataStyle(item.id, item.geode_object_type);
+  const addViewerTask = addDataTask.then(() => hybridViewerStore.addItem(item.id));
+  const applyStyleTask = Promise.all([registerTask, addDataComponentsTask, addStyleTask]).then(() =>
+    dataStyleStore.applyDefaultStyle(item.id),
+  );
   await Promise.all([
     registerTask,
     addDataTask,
@@ -77,32 +66,29 @@ async function importItem(item) {
     addDataRelationsTask,
     addViewerTask,
     applyStyleTask,
-  ])
-  return item.id
+  ]);
+  return item.id;
 }
 
 async function importFile(filename, geode_object_type) {
-  const geodeStore = useGeodeStore()
-  const response = await geodeStore.request(
-    back_schemas.opengeodeweb_back.save_viewable_file,
-    {
-      geode_object_type,
-      filename,
-    },
-  )
+  const geodeStore = useGeodeStore();
+  const response = await geodeStore.request(back_schemas.opengeodeweb_back.save_viewable_file, {
+    geode_object_type,
+    filename,
+  });
 
-  const item = buildImportItemFromPayloadApi(response, geode_object_type)
-  return importItem(item)
+  const item = buildImportItemFromPayloadApi(response, geode_object_type);
+  return importItem(item);
 }
 
 async function importWorkflowFromSnapshot(items) {
-  console.log("[importWorkflowFromSnapshot] start", { count: items?.length })
-  const hybridViewerStore = useHybridViewerStore()
+  console.log("[importWorkflowFromSnapshot] start", { count: items?.length });
+  const hybridViewerStore = useHybridViewerStore();
 
-  const ids = await Promise.all(items.map((item) => importItem(item)))
-  hybridViewerStore.remoteRender()
-  console.log("[importWorkflowFromSnapshot] done", { ids })
-  return ids
+  const ids = await Promise.all(items.map((item) => importItem(item)));
+  hybridViewerStore.remoteRender();
+  console.log("[importWorkflowFromSnapshot] done", { ids });
+  return ids;
 }
 
-export { importFile, importWorkflow, importWorkflowFromSnapshot, importItem }
+export { importFile, importWorkflow, importWorkflowFromSnapshot, importItem };

package/app/utils/local/app_mode.js

@@ -2,6 +2,6 @@ const appMode = {
   DESKTOP: "DESKTOP",
   BROWSER: "BROWSER",
   CLOUD: "CLOUD",
-}
+};
 
-export { appMode }
+export { appMode };

package/app/utils/local/cleanup.js

@@ -1,151 +1,145 @@
 // Node imports
-import fs from "node:fs"
-import path from "node:path"
-import { setTimeout } from "node:timers/promises"
+import fs from "node:fs";
+import path from "node:path";
+import { setTimeout } from "node:timers/promises";
 
 // Third party imports
-import { WebSocket } from "ws"
-import pTimeout from "p-timeout"
-import { rimraf } from "rimraf"
+import { WebSocket } from "ws";
+import pTimeout from "p-timeout";
+import { rimraf } from "rimraf";
 
-const MAX_DELETE_FOLDER_RETRIES = 5
+const MAX_DELETE_FOLDER_RETRIES = 5;
 
 async function deleteFolderRecursive(folderPath) {
   if (!fs.existsSync(folderPath)) {
-    console.log(`Folder ${folderPath} does not exist.`)
-    return
+    console.log(`Folder ${folderPath} does not exist.`);
+    return;
   }
   for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
     try {
-      console.log(`Deleting folder: ${folderPath}`)
+      console.log(`Deleting folder: ${folderPath}`);
       // oxlint-disable-next-line no-await-in-loop
-      await rimraf(folderPath)
-      console.log(`Deleted folder: ${folderPath}`)
-      return
+      await rimraf(folderPath);
+      console.log(`Deleted folder: ${folderPath}`);
+      return;
     } catch (error) {
-      console.error(`Error deleting folder ${folderPath}:`, error)
+      console.error(`Error deleting folder ${folderPath}:`, error);
       // Wait before retrying
-      const MILLISECONDS_PER_RETRY = 1000
-      const DELAY = MILLISECONDS_PER_RETRY * (i + 1)
+      const MILLISECONDS_PER_RETRY = 1000;
+      const DELAY = MILLISECONDS_PER_RETRY * (i + 1);
       // oxlint-disable-next-line no-await-in-loop
-      await setTimeout(DELAY)
-      console.log("Retrying delete folder")
+      await setTimeout(DELAY);
+      console.log("Retrying delete folder");
     }
   }
 }
 
 function killHttpMicroservice(microservice) {
-  console.log("killHttpMicroservice", { ...microservice })
-  const failMessage = `Failed to kill ${microservice.name}`
+  console.log("killHttpMicroservice", { ...microservice });
+  const failMessage = `Failed to kill ${microservice.name}`;
   async function do_kill() {
     try {
       await fetch(microservice.url, {
         method: microservice.method,
-      })
-      throw new Error(failMessage)
+      });
+      throw new Error(failMessage);
     } catch (error) {
-      console.log(`${microservice.name} closed`, error)
+      console.log(`${microservice.name} closed`, error);
     }
   }
   return pTimeout(do_kill(), {
     milliseconds: 5000,
     message: failMessage,
-  })
+  });
 }
 
 function killWebsocketMicroservice(microservice) {
-  console.log("killWebsocketMicroservice", { ...microservice })
-  const failMessage = `Failed to kill ${microservice.name}`
-  const successMessage = `Disconnected from ${microservice.name} WebSocket server`
+  console.log("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)
+      const socket = new WebSocket(microservice.url);
       socket.on("open", () => {
-        console.log("Connected to WebSocket server")
+        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)
+        const message = data.toString();
+        console.log("Received from server:", message);
         if (message.includes("hello")) {
           socket.send(
             JSON.stringify({
               id: "application.exit",
               method: "application.exit",
             }),
-          )
-          console.log(successMessage)
-          socket.close()
-          resolve()
+          );
+          console.log(successMessage);
+          socket.close();
+          resolve();
         }
-      })
+      });
       socket.on("close", () => {
-        console.log(successMessage)
-        resolve()
-      })
+        console.log(successMessage);
+        resolve();
+      });
       socket.on("error", (error) => {
-        console.error("WebSocket error:", error)
-        socket.close()
-        resolve()
-      })
-    })
+        console.error("WebSocket error:", error);
+        socket.close();
+        resolve();
+      });
+    });
   }
   return pTimeout(do_kill(), {
     milliseconds: 5000,
     message: failMessage,
-  })
+  });
 }
 
 function killMicroservice(microservice) {
   if (microservice.type === "back") {
-    return killHttpMicroservice(microservice)
-  } else if (microservice.type === "viewer") {
-    return killWebsocketMicroservice(microservice)
-  } else {
-    throw new Error(`Unknown microservice type: ${microservice.type}`)
+    return killHttpMicroservice(microservice);
   }
+  if (microservice.type === "viewer") {
+    return killWebsocketMicroservice(microservice);
+  }
+  throw new Error(`Unknown microservice type: ${microservice.type}`);
 }
 
 function killMicroservices(microservices) {
-  console.log("killMicroservices", { microservices })
+  console.log("killMicroservices", { microservices });
   return Promise.all(
-    microservices.map(
-      async (microservice) => await killMicroservice(microservice),
-    ),
-  )
+    microservices.map(async (microservice) => await killMicroservice(microservice)),
+  );
 }
 
 function projectMicroservices(projectFolderPath) {
-  console.log("projectMicroservices", { projectFolderPath })
-  const filePath = microservicesMetadatasPath(projectFolderPath)
+  console.log("projectMicroservices", { projectFolderPath });
+  const filePath = microservicesMetadatasPath(projectFolderPath);
 
   if (!fs.existsSync(filePath)) {
-    const microservicesMetadatas = { microservices: [] }
-    fs.writeFileSync(
-      filePath,
-      JSON.stringify(microservicesMetadatas, undefined, 2),
-      "utf8",
-    )
+    const microservicesMetadatas = { microservices: [] };
+    fs.writeFileSync(filePath, JSON.stringify(microservicesMetadatas, undefined, 2), "utf8");
   }
-  const content = JSON.parse(fs.readFileSync(filePath, "utf8"))
-  return content.microservices
+  const content = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return content.microservices;
 }
 
 async function cleanupBackend(projectFolderPath) {
-  const microservices = projectMicroservices(projectFolderPath)
-  await killMicroservices(microservices)
-  await deleteFolderRecursive(projectFolderPath)
+  const microservices = projectMicroservices(projectFolderPath);
+  await killMicroservices(microservices);
+  await deleteFolderRecursive(projectFolderPath);
 }
 
 function microservicesMetadatasPath(projectFolderPath) {
-  return path.join(projectFolderPath, "microservices.json")
+  return path.join(projectFolderPath, "microservices.json");
 }
 
-export { cleanupBackend, microservicesMetadatasPath }
+export { cleanupBackend, microservicesMetadatasPath };