@geode/opengeodeweb-front 10.24.2 → 10.25.0-rc.2

package/app/components/Viewer/Generic/Mesh/PolyhedraOptions.vue

@@ -128,7 +128,7 @@ const polyhedron_attribute_color_map = computed({
           v-model:polyhedron_attribute_range="polyhedron_attribute_range"
           v-model:polyhedron_attribute_color_map="polyhedron_attribute_color_map"
           :capabilities="{
-            vertex: { available: true, hasColorMap: false },
+            vertex: { available: true, hasColorMap: true },
             polyhedron: { available: true, hasColorMap: true },
           }"
         />

package/app/stores/app.js

@@ -2,6 +2,9 @@
 import { api_fetch } from "@ogw_internal/utils/api_fetch.js";
 import { upload_file } from "@ogw_internal/utils/upload_file.js";
 
+import { killExtension } from "@ogw_front/utils/extension.js";
+import { useInfraStore } from "@ogw_front/stores/infra";
+
 // oxlint-disable-next-line max-lines-per-function, max-statements
 export const useAppStore = defineStore("app", () => {
   const stores = [];
@@ -155,51 +158,41 @@ export const useAppStore = defineStore("app", () => {
     return [...loadedExtensions.value.values()];
   }
 
-  function unloadExtension(id) {
-    const extensionData = getExtension(id);
-    if (!extensionData) {
-      return false;
-    }
-    if (extensionData.module && typeof extensionData.module.uninstall === "function") {
-      try {
-        extensionData.module.uninstall(extensionAPI.value);
-        console.log(`[AppStore] Extension uninstall called: ${id}`);
-      } catch (error) {
-        console.error(`[AppStore] Error calling uninstall for ${id}:`, error);
-      }
-    }
-
-    if (extensionAPI.value && typeof extensionAPI.value.unregisterToolsByExtension === "function") {
-      extensionAPI.value.unregisterToolsByExtension(id);
-    }
+  async function unloadExtension(extensionId) {
+    console.log(`[AppStore] Unloading extension: ${extensionId}`);
+    const infraStore = useInfraStore();
+    await infraStore.unregister_microservice(extensionId);
+    await killExtension(extensionId);
 
-    loadedExtensions.value.delete(id);
-    console.log(`[AppStore] Extension unloaded: ${id}`);
+    loadedExtensions.value.delete(extensionId);
+    console.log(`[AppStore] Extension unloaded: ${extensionId}`);
     return true;
   }
 
-  function toggleExtension(id) {
-    const extensionData = getExtension(id);
+  function toggleExtension(extensionId) {
+    const extensionData = getExtension(extensionId);
     if (!extensionData) {
       return false;
     }
     extensionData.enabled = !extensionData.enabled;
-    console.log(`[AppStore] Extension ${extensionData.enabled ? "enabled" : "disabled"}: ${id}`);
+    console.log(
+      `[AppStore] Extension ${extensionData.enabled ? "enabled" : "disabled"}: ${extensionId}`,
+    );
     return extensionData.enabled;
   }
 
-  function setExtensionEnabled(id, enabled) {
-    const extensionData = getExtension(id);
+  function setExtensionEnabled(extensionId, enabled) {
+    const extensionData = getExtension(extensionId);
     if (!extensionData) {
       return false;
     }
     extensionData.enabled = enabled;
-    console.log(`[AppStore] Extension ${enabled ? "enabled" : "disabled"}: ${id}`);
+    console.log(`[AppStore] Extension ${enabled ? "enabled" : "disabled"}: ${extensionId}`);
     return true;
   }
 
-  function getExtensionEnabled(id) {
-    return getExtension(id)?.enabled ?? false;
+  function getExtensionEnabled(extensionId) {
+    return getExtension(extensionId)?.enabled ?? false;
   }
 
   function upload(file, callbacks = {}) {

package/app/stores/infra.js

@@ -30,6 +30,13 @@ export const useInfraStore = defineStore("infra", {
         console.log("[INFRA] Microservice registered:", store_name);
       }
     },
+    unregister_microservice(microserviceId) {
+      console.log("[INFRA] Unregistering microservice:", microserviceId);
+      this.microservices = this.microservices.filter(
+        (microservice) => microservice.$id !== microserviceId,
+      );
+      console.log("[INFRA] Microservice unregistered:", microserviceId);
+    },
     create_backend(name, email, launch) {
       console.log("[INFRA] Starting create_backend - Mode:", this.app_mode);
       console.log(

package/app/utils/config.js

@@ -1,5 +1,6 @@
 // Node.js imports
 import path from "node:path";
+import { unlink } from "node:fs";
 
 // Third party imports
 import Conf from "conf";
@@ -31,9 +32,30 @@ function addExtensionToConf(projectName, { extensionID, extensionPath }) {
   projectConfig.set(`extensions.${extensionID}.path`, extensionPath);
 }
 
+async function removeExtensionFromConf(projectName, extensionID) {
+  const projectConfig = projectConf(projectName);
+  const extensionArchivePath = extensionPathFromConf(projectName, extensionID);
+
+  await unlink(extensionArchivePath, (error) => {
+    if (error) {
+      throw error;
+    }
+    console.log(`${extensionArchivePath} was deleted`);
+  });
+  projectConfig.delete(`extensions.${extensionID}`);
+  console.log(`${extensionID} was deleted from ${projectName} config`);
+}
+
 function extensionPathFromConf(projectName, extensionID) {
   const projectConfig = projectConf(projectName);
   return projectConfig.get(`extensions.${extensionID}.path`);
 }
 
-export { confFolderPath, projectConf, extensionsConf, addExtensionToConf, extensionPathFromConf };
+export {
+  confFolderPath,
+  projectConf,
+  extensionsConf,
+  addExtensionToConf,
+  removeExtensionFromConf,
+  extensionPathFromConf,
+};

package/app/utils/extension.js

@@ -95,10 +95,35 @@ function runExtensions() {
   return appStore.request({ schema, params });
 }
 
+function killExtension(extensionId) {
+  const appStore = useAppStore();
+  const { projectFolderPath } = appStore;
+  const { PROJECT: projectName } = useRuntimeConfig().public;
+  const params = { extensionId, projectFolderPath, projectName };
+
+  console.log(`[AppStore] Killing extension: ${extensionId}`, { params });
+
+  const schema = {
+    $id: "/api/extensions/kill",
+    methods: ["POST"],
+    type: "object",
+    properties: {
+      extensionId: { type: "string" },
+      projectFolderPath: { type: "string" },
+      projectName: { type: "string" },
+    },
+    required: ["extensionId", "projectFolderPath", "projectName"],
+    additionalProperties: false,
+  };
+
+  return appStore.request({ schema, params });
+}
+
 export {
   importExtensionFile,
   unloadExtension,
   uploadExtension,
   registerRunningExtensions,
   runExtensions,
+  killExtension,
 };

package/app/utils/local/cleanup.js

@@ -38,14 +38,9 @@ function killHttpMicroservice(microservice) {
   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);
-    } catch (error) {
-      console.log(`${microservice.name} closed`, error);
-    }
+    await $fetch(microservice.url, {
+      method: microservice.method,
+    });
   }
   return pTimeout(do_kill(), {
     milliseconds: 5000,
@@ -103,20 +98,27 @@ function killWebsocketMicroservice(microservice) {
   });
 }
 
-function killMicroservice(microservice) {
+async function killMicroservice(microservice, microservices) {
   if (microservice.type === "back") {
-    return killHttpMicroservice(microservice);
+    await killHttpMicroservice(microservice);
+  } else if (microservice.type === "viewer") {
+    await killWebsocketMicroservice(microservice);
+  } else {
+    throw new Error(`Unknown microservice type: ${microservice.type}`);
   }
-  if (microservice.type === "viewer") {
-    return killWebsocketMicroservice(microservice);
+
+  if (microservices) {
+    const index = microservices.indexOf(microservice);
+    if (index !== -1) {
+      microservices.splice(index, 1);
+    }
   }
-  throw new Error(`Unknown microservice type: ${microservice.type}`);
 }
 
 function killMicroservices(microservices) {
   console.log("killMicroservices", { microservices });
   return Promise.all(
-    microservices.map(async (microservice) => await killMicroservice(microservice)),
+    microservices.map((microservice) => killMicroservice(microservice, microservices)),
   );
 }
 
@@ -142,8 +144,19 @@ async function cleanupBackend(projectFolderPath) {
   await deleteFolderRecursive(projectFolderPath);
 }
 
+function getMicroserviceByName(microservices, name) {
+  return microservices.find((microservice) => microservice.name === name);
+}
+
 function microservicesMetadatasPath(projectFolderPath) {
   return path.join(projectFolderPath, "microservices.json");
 }
 
-export { cleanupBackend, microservicesMetadatasPath, projectMicroservices };
+export {
+  cleanupBackend,
+  deleteFolderRecursive,
+  killMicroservice,
+  microservicesMetadatasPath,
+  projectMicroservices,
+  getMicroserviceByName,
+};

package/app/utils/local/path.js

@@ -49,6 +49,10 @@ function generateProjectFolderPath(projectName) {
   return path.join(os.tmpdir(), projectName.replaceAll("/", "_"), uuidv4());
 }
 
+function extensionFolderPath(projectFolderPath, extensionID) {
+  return path.join(projectFolderPath, "extensions", extensionID);
+}
+
 async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, frontendFile) {
   const localExtensionPath = path.join(rootPath, "..", extentionRepoName);
   const localExtensionDistPath = path.join(localExtensionPath, "dist");
@@ -108,6 +112,7 @@ async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPa
 export {
   createPath,
   extensionFrontendPath,
+  extensionFolderPath,
   executablePath,
   executableName,
   generateProjectFolderPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.24.2",
+  "version": "10.25.0-rc.2",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -34,8 +34,8 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@google-cloud/run": "3.2.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",

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

@@ -0,0 +1,43 @@
+// Node imports
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import {
+  deleteFolderRecursive,
+  getMicroserviceByName,
+  killMicroservice,
+  projectMicroservices,
+} from "@geode/opengeodeweb-front/app/utils/local/cleanup.js";
+import { extensionFolderPath } from "@geode/opengeodeweb-front/app/utils/local/path.js";
+import { removeExtensionFromConf } from "@geode/opengeodeweb-front/app/utils/config.js";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const body = await readBody(event);
+    const { projectFolderPath, projectName, extensionId } = body;
+
+    console.log({ projectFolderPath, projectName, extensionId });
+
+    const microservices = projectMicroservices(projectFolderPath);
+    const microservice = getMicroserviceByName(microservices, extensionId);
+    if (!microservice) {
+      throw new Error(`Microservice ${extensionId} not found`);
+    }
+
+    await removeExtensionFromConf(projectName, extensionId);
+    await deleteFolderRecursive(extensionFolderPath(projectFolderPath, extensionId));
+    await killMicroservice(microservice, microservices);
+
+    return {
+      statusCode: 200,
+    };
+  } catch (error) {
+    console.error("Error killing extension:", error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    });
+  }
+});

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

@@ -12,13 +12,12 @@ import {
 } from "@geode/opengeodeweb-front/app/utils/local/microservices.js";
 import {
   executableName,
+  extensionFolderPath,
   extensionFrontendPath,
 } from "@geode/opengeodeweb-front/app/utils/local/path.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;
-
 export default defineEventHandler(async (event) => {
   try {
     const body = await readBody(event);
@@ -30,7 +29,7 @@ export default defineEventHandler(async (event) => {
         const extensionPath = extensionsConfig[extensionID].path;
         const unzippedExtensionPath = await unzipFile(
           extensionPath,
-          path.join(projectFolderPath, "extensions"),
+          extensionFolderPath(projectFolderPath, extensionID),
         );
         const metadataPath = path.join(unzippedExtensionPath, "metadata.json");
         const metadataContent = await fs.promises.readFile(metadataPath, "utf8");
@@ -95,7 +94,7 @@ export default defineEventHandler(async (event) => {
     );
 
     return {
-      statusCode: CODE_200,
+      statusCode: 200,
       extensionsArray,
     };
   } catch (error) {