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

package/app/composables/project_manager.js

@@ -1,110 +1,100 @@
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-import fileDownload from "js-file-download"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
+import fileDownload from "js-file-download";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-import { importWorkflowFromSnapshot } from "@ogw_front/utils/file_import_workflow"
+import { importWorkflowFromSnapshot } from "@ogw_front/utils/file_import_workflow";
 
-import { useAppStore } from "@ogw_front/stores/app"
-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 { useViewerStore } from "@ogw_front/stores/viewer"
+import { useAppStore } from "@ogw_front/stores/app";
+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 { useViewerStore } from "@ogw_front/stores/viewer";
 
 export function useProjectManager() {
   async function exportProject() {
-    console.log("[export triggered]")
-    const appStore = useAppStore()
-    const geodeStore = useGeodeStore()
-    const snapshot = await appStore.exportStores()
-    const schema = back_schemas.opengeodeweb_back.export_project
-    const defaultName = "project.vease"
+    console.log("[export triggered]");
+    const appStore = useAppStore();
+    const geodeStore = useGeodeStore();
+    const snapshot = await appStore.exportStores();
+    const schema = back_schemas.opengeodeweb_back.export_project;
+    const defaultName = "project.vease";
 
     const result = await $fetch(schema.$id, {
       baseURL: geodeStore.base_url,
       method: schema.methods.find((method) => method !== "OPTIONS"),
       body: { snapshot, filename: defaultName },
-    })
-    fileDownload(result, defaultName)
-    return { result }
+    });
+    fileDownload(result, defaultName);
+    return { result };
   }
 
   async function importProjectFile(file) {
-    const geodeStore = useGeodeStore()
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
-    const dataStore = useDataStore()
-    const treeviewStore = useTreeviewStore()
-    const hybridViewerStore = useHybridViewerStore()
+    const geodeStore = useGeodeStore();
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
+    const dataStore = useDataStore();
+    const treeviewStore = useTreeviewStore();
+    const hybridViewerStore = useHybridViewerStore();
 
-    await viewerStore.ws_connect()
+    await viewerStore.ws_connect();
 
-    const { client } = viewerStore
+    const { client } = viewerStore;
     if (client && client.getConnection && client.getConnection().getSession) {
-      await client
-        .getConnection()
-        .getSession()
-        .call("opengeodeweb_viewer.release_database", [{}])
+      await client.getConnection().getSession().call("opengeodeweb_viewer.release_database", [{}]);
     }
 
     await viewerStore.request(
       viewer_schemas.opengeodeweb_viewer.viewer.reset_visualization,
       {},
       undefined,
-    )
+    );
 
-    treeviewStore.clear()
-    dataStore.clear()
-    hybridViewerStore.clear()
+    treeviewStore.clear();
+    dataStore.clear();
+    hybridViewerStore.clear();
 
-    const schemaImport = back_schemas.opengeodeweb_back.import_project
-    const form = new FormData()
-    const originalFileName = file && file.name ? file.name : "project.vease"
+    const schemaImport = back_schemas.opengeodeweb_back.import_project;
+    const form = new FormData();
+    const originalFileName = file && file.name ? file.name : "project.vease";
     if (!originalFileName.toLowerCase().endsWith(".vease")) {
-      throw new Error("Uploaded file must be a .vease")
+      throw new Error("Uploaded file must be a .vease");
     }
-    form.append("file", file, originalFileName)
+    form.append("file", file, originalFileName);
 
     const result = await $fetch(schemaImport.$id, {
       baseURL: geodeStore.base_url,
       method: "POST",
       body: form,
-    })
-    const snapshot = result && result.snapshot ? result.snapshot : {}
-
-    treeviewStore.isImporting = true
-
-    const { client: client2 } = viewerStore
-    if (
-      client2 &&
-      client2.getConnection &&
-      client2.getConnection().getSession
-    ) {
-      await client2
-        .getConnection()
-        .getSession()
-        .call("opengeodeweb_viewer.import_project", [{}])
+    });
+    const snapshot = result && result.snapshot ? result.snapshot : {};
+
+    treeviewStore.isImporting = true;
+
+    const { client: client2 } = viewerStore;
+    if (client2 && client2.getConnection && client2.getConnection().getSession) {
+      await client2.getConnection().getSession().call("opengeodeweb_viewer.import_project", [{}]);
     }
 
-    await treeviewStore.importStores(snapshot.treeview || {})
-    await hybridViewerStore.initHybridViewer()
-    await hybridViewerStore.importStores(snapshot.hybridViewer || {})
+    await treeviewStore.importStores(snapshot.treeview || {});
+    await hybridViewerStore.initHybridViewer();
+    await hybridViewerStore.importStores(snapshot.hybridViewer || {});
 
-    const items = snapshot?.data?.items || []
+    const items = snapshot?.data?.items || [];
 
-    await importWorkflowFromSnapshot(items)
-    await hybridViewerStore.importStores(snapshot.hybridViewer || {})
+    await importWorkflowFromSnapshot(items);
+    await hybridViewerStore.importStores(snapshot.hybridViewer || {});
     {
-      await dataStyleStore.importStores(snapshot.dataStyle || {})
+      await dataStyleStore.importStores(snapshot.dataStyle || {});
     }
     {
-      await dataStyleStore.applyAllStylesFromState()
+      await dataStyleStore.applyAllStylesFromState();
     }
 
-    treeviewStore.finalizeImportSelection()
-    treeviewStore.isImporting = false
+    treeviewStore.finalizeImportSelection();
+    treeviewStore.isImporting = false;
   }
 
-  return { exportProject, importProjectFile }
+  return { exportProject, importProjectFile };
 }

package/app/composables/run_function_when_microservices_connected.js

@@ -1,16 +1,16 @@
-import { useInfraStore } from "@ogw_front/stores/infra"
+import { useInfraStore } from "@ogw_front/stores/infra";
 export function run_function_when_microservices_connected(function_to_run) {
-  const infraStore = useInfraStore()
-  const { microservices_connected } = storeToRefs(infraStore)
-  console.log("inside microservices_connected", microservices_connected.value)
+  const infraStore = useInfraStore();
+  const { microservices_connected } = storeToRefs(infraStore);
+  console.log("inside microservices_connected", microservices_connected.value);
   if (microservices_connected.value) {
-    function_to_run()
+    function_to_run();
   } else {
     watch(microservices_connected, (value) => {
       if (value) {
-        console.log("watch microservices_connected", value)
-        function_to_run()
+        console.log("watch microservices_connected", value);
+        function_to_run();
       }
-    })
+    });
   }
 }

package/app/plugins/auto_store_register.js

@@ -1,28 +1,26 @@
-import { useAppStore } from "@ogw_front/stores/app"
+import { useAppStore } from "@ogw_front/stores/app";
 
 function autoStoreRegister({ store }) {
   if (store.$id === "app") {
-    return
+    return;
   }
 
-  const appStore = useAppStore()
-  appStore.registerStore(store)
-  console.log(`[AutoRegister] Store "${store.$id}" processed`)
+  const appStore = useAppStore();
+  appStore.registerStore(store);
+  console.log(`[AutoRegister] Store "${store.$id}" processed`);
 }
 
 export default defineNuxtPlugin({
   name: "auto-store-register",
   dependsOn: ["pinia"],
   setup(nuxtApp) {
-    const { $pinia } = nuxtApp
+    const { $pinia } = nuxtApp;
     if (!$pinia) {
-      console.warn("Pinia instance not available.")
-      return
+      console.warn("Pinia instance not available.");
+      return;
     }
 
-    $pinia.use(autoStoreRegister)
-    console.log(
-      "[AUTOREGISTER PLUGIN] Loaded automatically from OpenGeodeWeb-Front",
-    )
+    $pinia.use(autoStoreRegister);
+    console.log("[AUTOREGISTER PLUGIN] Loaded automatically from OpenGeodeWeb-Front");
   },
-})
+});

package/app/stores/app.js

@@ -1,269 +1,249 @@
-import { api_fetch } from "@ogw_internal/utils/api_fetch.js"
-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 = []
+  const stores = [];
 
   function registerStore(store) {
-    const isAlreadyRegistered = stores.some(
-      (registeredStore) => registeredStore.$id === store.$id,
-    )
+    const isAlreadyRegistered = stores.some((registeredStore) => registeredStore.$id === store.$id);
     if (isAlreadyRegistered) {
-      console.log(
-        `[AppStore] Store "${store.$id}" already registered, skipping`,
-      )
-      return
+      console.log(`[AppStore] Store "${store.$id}" already registered, skipping`);
+      return;
     }
-    console.log("[AppStore] Registering store", store.$id)
-    stores.push(store)
+    console.log("[AppStore] Registering store", store.$id);
+    stores.push(store);
   }
 
   async function exportStores(params = {}) {
-    const snapshot = {}
-    let exportCount = 0
+    const snapshot = {};
+    let exportCount = 0;
 
-    console.log(
-      `[AppStore] Exporting stores, total registered: ${stores.length}`,
-    )
+    console.log(`[AppStore] Exporting stores, total registered: ${stores.length}`);
     await Promise.all(
       stores.map(async (store) => {
         if (!store.exportStores) {
-          return
+          return;
         }
-        const storeId = store.$id
+        const storeId = store.$id;
         try {
-          snapshot[storeId] = await store.exportStores(params)
-          exportCount += 1
+          snapshot[storeId] = await store.exportStores(params);
+          exportCount += 1;
         } catch (error) {
-          console.error(`[AppStore] Error exporting store "${storeId}":`, error)
+          console.error(`[AppStore] Error exporting store "${storeId}":`, error);
         }
       }),
-    )
-    console.log(
-      `[AppStore] Exported ${exportCount} stores; snapshot keys:`,
-      Object.keys(snapshot),
-    )
-    return snapshot
+    );
+    console.log(`[AppStore] Exported ${exportCount} stores; snapshot keys:`, Object.keys(snapshot));
+    return snapshot;
   }
 
   async function importStores(snapshot) {
     if (!snapshot) {
-      console.warn("[AppStore] import called with invalid snapshot")
-      return
+      console.warn("[AppStore] import called with invalid snapshot");
+      return;
     }
-    console.log("[AppStore] Import snapshot keys:", Object.keys(snapshot || {}))
+    console.log("[AppStore] Import snapshot keys:", Object.keys(snapshot || {}));
 
-    let importedCount = 0
-    const notFoundStores = []
+    let importedCount = 0;
+    const notFoundStores = [];
     await Promise.all(
       stores.map(async (store) => {
         if (!store.importStores) {
-          return
+          return;
         }
-        const storeId = store.$id
+        const storeId = store.$id;
         if (!snapshot[storeId]) {
-          notFoundStores.push(storeId)
-          return
+          notFoundStores.push(storeId);
+          return;
         }
         try {
-          await store.importStores(snapshot[storeId])
-          importedCount += 1
+          await store.importStores(snapshot[storeId]);
+          importedCount += 1;
         } catch (error) {
-          console.error(`[AppStore] Error importing store "${storeId}":`, error)
+          console.error(`[AppStore] Error importing store "${storeId}":`, error);
         }
       }),
-    )
+    );
     if (notFoundStores.length > 0) {
-      console.warn(
-        `[AppStore] Stores not found in snapshot: ${notFoundStores.join(", ")}`,
-      )
+      console.warn(`[AppStore] Stores not found in snapshot: ${notFoundStores.join(", ")}`);
     }
-    console.log(`[AppStore] Imported ${importedCount} stores`)
+    console.log(`[AppStore] Imported ${importedCount} stores`);
   }
 
-  const loadedExtensions = ref(new Map())
-  const extensionAPI = ref(undefined)
-  const codeTransformer = ref(undefined)
+  const loadedExtensions = ref(new Map());
+  const extensionAPI = ref(undefined);
+  const codeTransformer = ref(undefined);
 
   function setExtensionAPI(api) {
-    extensionAPI.value = api
+    extensionAPI.value = api;
   }
 
   function setCodeTransformer(transformer) {
-    codeTransformer.value = transformer
+    codeTransformer.value = transformer;
   }
 
   function getExtension(id) {
-    return loadedExtensions.value.get(id)
+    return loadedExtensions.value.get(id);
   }
 
   async function loadExtension(path, backendPath = undefined) {
     try {
-      let finalURL = path
+      let finalURL = path;
 
       if (codeTransformer.value && path.startsWith("blob:")) {
-        const response = await fetch(path)
-        const code = await response.text()
-        const transformedCode = codeTransformer.value(code)
+        const response = await fetch(path);
+        const code = await response.text();
+        const transformedCode = codeTransformer.value(code);
 
         const newBlob = new Blob([transformedCode], {
           type: "application/javascript",
-        })
-        finalURL = URL.createObjectURL(newBlob)
+        });
+        finalURL = URL.createObjectURL(newBlob);
       }
-      const extensionModule = await import(/* @vite-ignore */ finalURL)
+      // oxlint-disable-next-line no-inline-comments
+      const extensionModule = await import(/* @vite-ignore */ finalURL);
 
       if (finalURL !== path && finalURL.startsWith("blob:")) {
-        URL.revokeObjectURL(finalURL)
+        URL.revokeObjectURL(finalURL);
       }
 
       if (!extensionModule.metadata?.id) {
-        throw new Error("Extension must have metadata.id")
+        throw new Error("Extension must have metadata.id");
       }
 
-      const extensionId = extensionModule.metadata.id
+      const extensionId = extensionModule.metadata.id;
 
       if (loadedExtensions.value.has(extensionId)) {
-        console.warn(`[AppStore] Extension "${extensionId}" is already loaded`)
-        throw new Error(`Extension "${extensionId}" is already loaded.`)
+        console.warn(`[AppStore] Extension "${extensionId}" is already loaded`);
+        throw new Error(`Extension "${extensionId}" is already loaded.`);
       }
 
       if (!extensionAPI.value) {
-        throw new Error("Extension API not initialized")
+        throw new Error("Extension API not initialized");
       }
 
-      if (typeof extensionModule.install === "function") {
-        await extensionModule.install(extensionAPI.value, backendPath)
-
-        const extensionData = {
-          module: extensionModule,
-          id: extensionId,
-          path,
-          backendPath,
-          loadedAt: new Date().toISOString(),
-          metadata: extensionModule.metadata,
-          enabled: true,
-        }
-        loadedExtensions.value.set(extensionId, extensionData)
-
-        console.log(`[AppStore] Extension loaded successfully: ${extensionId}`)
-        return extensionModule
-      } else {
-        throw new Error("Extension must export an install function")
+      if (typeof extensionModule.install !== "function") {
+        throw new TypeError("Extension must export an install function");
       }
+
+      await extensionModule.install(extensionAPI.value, backendPath);
+
+      const extensionData = {
+        module: extensionModule,
+        id: extensionId,
+        path,
+        backendPath,
+        loadedAt: new Date().toISOString(),
+        metadata: extensionModule.metadata,
+        enabled: true,
+      };
+      loadedExtensions.value.set(extensionId, extensionData);
+
+      console.log(`[AppStore] Extension loaded successfully: ${extensionId}`);
+      return extensionModule;
     } catch (error) {
-      console.error(`[AppStore] Failed to load extension from ${path}:`, error)
-      throw error
+      console.error(`[AppStore] Failed to load extension from ${path}:`, error);
+      throw error;
     }
   }
 
   function getLoadedExtensions() {
-    return [...loadedExtensions.value.values()]
+    return [...loadedExtensions.value.values()];
   }
 
   function unloadExtension(id) {
-    const extensionData = getExtension(id)
+    const extensionData = getExtension(id);
     if (!extensionData) {
-      return false
+      return false;
     }
-    if (
-      extensionData.module &&
-      typeof extensionData.module.uninstall === "function"
-    ) {
+    if (extensionData.module && typeof extensionData.module.uninstall === "function") {
       try {
-        extensionData.module.uninstall(extensionAPI.value)
-        console.log(`[AppStore] Extension uninstall called: ${id}`)
+        extensionData.module.uninstall(extensionAPI.value);
+        console.log(`[AppStore] Extension uninstall called: ${id}`);
       } catch (error) {
-        console.error(`[AppStore] Error calling uninstall for ${id}:`, error)
+        console.error(`[AppStore] Error calling uninstall for ${id}:`, error);
       }
     }
 
-    if (
-      extensionAPI.value &&
-      typeof extensionAPI.value.unregisterToolsByExtension === "function"
-    ) {
-      extensionAPI.value.unregisterToolsByExtension(id)
+    if (extensionAPI.value && typeof extensionAPI.value.unregisterToolsByExtension === "function") {
+      extensionAPI.value.unregisterToolsByExtension(id);
     }
 
-    loadedExtensions.value.delete(id)
-    console.log(`[AppStore] Extension unloaded: ${id}`)
-    return true
+    loadedExtensions.value.delete(id);
+    console.log(`[AppStore] Extension unloaded: ${id}`);
+    return true;
   }
 
   function toggleExtension(id) {
-    const extensionData = getExtension(id)
+    const extensionData = getExtension(id);
     if (!extensionData) {
-      return false
+      return false;
     }
-    extensionData.enabled = !extensionData.enabled
-    console.log(
-      `[AppStore] Extension ${extensionData.enabled ? "enabled" : "disabled"}: ${id}`,
-    )
-    return extensionData.enabled
+    extensionData.enabled = !extensionData.enabled;
+    console.log(`[AppStore] Extension ${extensionData.enabled ? "enabled" : "disabled"}: ${id}`);
+    return extensionData.enabled;
   }
 
   function setExtensionEnabled(id, enabled) {
-    const extensionData = getExtension(id)
+    const extensionData = getExtension(id);
     if (!extensionData) {
-      return false
+      return false;
     }
-    extensionData.enabled = enabled
-    console.log(
-      `[AppStore] Extension ${enabled ? "enabled" : "disabled"}: ${id}`,
-    )
-    return true
+    extensionData.enabled = enabled;
+    console.log(`[AppStore] Extension ${enabled ? "enabled" : "disabled"}: ${id}`);
+    return true;
   }
 
   function getExtensionEnabled(id) {
-    return getExtension(id)?.enabled ?? false
+    return getExtension(id)?.enabled ?? false;
   }
 
   function upload(file, callbacks = {}) {
-    const route = "/api/extensions/upload"
-    const store = useAppStore()
+    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)
+          console.log("[APP] Request completed:", route);
           if (callbacks.response_function) {
-            await callbacks.response_function(response)
+            await callbacks.response_function(response);
           }
         },
       },
-    )
+    );
   }
 
   function request(schema, params, callbacks = {}) {
-    console.log("[APP] Request:", schema.$id)
+    console.log("[APP] Request:", schema.$id);
 
-    const store = useAppStore()
+    const store = useAppStore();
     return api_fetch(
       store,
       { schema, params },
       {
         ...callbacks,
         response_function: async (response) => {
-          console.log("[APP] Request completed:", schema.$id)
+          console.log("[APP] Request completed:", schema.$id);
           if (callbacks.response_function) {
-            await callbacks.response_function(response)
+            await callbacks.response_function(response);
           }
         },
       },
-    )
+    );
   }
 
-  const request_counter = ref(0)
+  const request_counter = ref(0);
   function start_request() {
-    request_counter.value += 1
+    request_counter.value += 1;
   }
   function stop_request() {
-    request_counter.value -= 1
+    request_counter.value -= 1;
   }
 
-  const projectFolderPath = ref("")
+  const projectFolderPath = ref("");
   function createProjectFolder() {
     const schema = {
       $id: "/api/app/project_folder_path",
@@ -272,18 +252,18 @@ export const useAppStore = defineStore("app", () => {
       properties: {},
       required: [],
       additionalProperties: true,
-    }
+    };
 
     return request(
       schema,
       {},
       {
-        response_function: async (response) => {
-          console.log(`[APP] ${response.projectFolderPath} created`)
-          projectFolderPath.value = response.projectFolderPath
+        response_function: (response) => {
+          console.log(`[APP] ${response.projectFolderPath} created`);
+          projectFolderPath.value = response.projectFolderPath;
         },
       },
-    )
+    );
   }
 
   return {
@@ -308,5 +288,5 @@ export const useAppStore = defineStore("app", () => {
     createProjectFolder,
     start_request,
     stop_request,
-  }
-})
+  };
+});