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

package/internal/utils/upload_file.js

@@ -1,55 +1,50 @@
-import { useFeedbackStore } from "@ogw_front/stores/feedback.js"
+import { useFeedbackStore } from "@ogw_front/stores/feedback.js";
 
 async function upload_file(
   microservice,
   { route, file },
   { request_error_function, response_function, response_error_function } = {},
 ) {
-  console.log("[UPLOAD_FILE] Uploading file", { route, file })
-  const feedbackStore = useFeedbackStore()
+  console.log("[UPLOAD_FILE] Uploading file", { route, file });
+  const feedbackStore = useFeedbackStore();
   if (!(file instanceof File)) {
-    throw new Error("file must be a instance of File")
+    throw new Error("file must be a instance of File");
   }
 
-  const body = new FormData()
-  body.append("file", file)
+  const body = new FormData();
+  body.append("file", file);
 
   const request_options = {
     method: "PUT",
     body: body,
-  }
-  microservice.start_request()
-  return $fetch(route, {
+  };
+  microservice.start_request();
+  return await $fetch(route, {
     baseURL: microservice.base_url || "",
     ...request_options,
     onRequestError({ error }) {
-      microservice.stop_request()
-      feedbackStore.add_error(error.code, route, error.message, error.stack)
+      microservice.stop_request();
+      feedbackStore.add_error(error.code, route, error.message, error.stack);
       if (request_error_function) {
-        request_error_function(error)
+        request_error_function(error);
       }
     },
     onResponse({ response }) {
       if (response.ok) {
-        microservice.stop_request()
+        microservice.stop_request();
         if (response_function) {
-          response_function(response)
+          response_function(response);
         }
       }
     },
     onResponseError({ response }) {
-      microservice.stop_request()
-      feedbackStore.add_error(
-        response.status,
-        route,
-        response.name,
-        response.description,
-      )
+      microservice.stop_request();
+      feedbackStore.add_error(response.status, route, response.name, response.description);
       if (response_error_function) {
-        response_error_function(response)
+        response_error_function(response);
       }
     },
-  })
+  });
 }
 
-export { upload_file }
+export { upload_file };

package/internal/utils/viewer_call.js

@@ -1,64 +1,51 @@
-import pTimeout from "p-timeout"
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
-import { validate_schema } from "@ogw_front/utils/validate_schema"
+import pTimeout from "p-timeout";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
+import { validate_schema } from "@ogw_front/utils/validate_schema";
 
-const ERROR_400 = 400
+const ERROR_400 = 400;
 
 export async function viewer_call(
   microservice,
   { schema, params = {} },
-  {
-    request_error_function,
-    response_function,
-    response_error_function,
-    timeout,
-  } = {},
+  { request_error_function, response_function, response_error_function, timeout } = {},
 ) {
-  const feedbackStore = useFeedbackStore()
+  const feedbackStore = useFeedbackStore();
 
-  const { valid, error: schema_error } = validate_schema(schema, params)
+  const { valid, error: schema_error } = validate_schema(schema, params);
 
   if (!valid) {
     if (process.env.NODE_ENV !== "production") {
-      console.log("Bad request", schema_error, schema, params)
+      console.log("Bad request", schema_error, schema, params);
     }
-    feedbackStore.add_error(ERROR_400, schema.$id, "Bad request", schema_error)
-    throw new Error(`${schema.$id}: ${schema_error}`)
+    feedbackStore.add_error(ERROR_400, schema.$id, "Bad request", schema_error);
+    throw new Error(`${schema.$id}: ${schema_error}`);
   }
 
-  const { client } = microservice
+  const { client } = microservice;
 
   async function performCall() {
     if (!client.getConnection) {
-      return
+      return;
     }
-    microservice.start_request()
+    microservice.start_request();
 
     try {
-      const value = await client
-        .getConnection()
-        .getSession()
-        .call(schema.$id, [params])
+      const value = await client.getConnection().getSession().call(schema.$id, [params]);
       if (response_function) {
-        response_function(value)
+        response_function(value);
       }
-      return value
+      return value;
     } catch (error) {
-      feedbackStore.add_error(
-        error.code,
-        schema.$id,
-        error.message,
-        error.message,
-      )
+      feedbackStore.add_error(error.code, schema.$id, error.message, error.message);
       if (request_error_function) {
-        request_error_function(error)
+        request_error_function(error);
       }
       if (response_error_function) {
-        response_error_function(error)
+        response_error_function(error);
       }
-      throw error
+      throw error;
     } finally {
-      microservice.stop_request()
+      microservice.stop_request();
     }
   }
 
@@ -66,8 +53,8 @@ export async function viewer_call(
     return await pTimeout(performCall(), {
       milliseconds: timeout,
       message: `${schema.$id}: Timed out after ${timeout}ms`,
-    })
+    });
   }
 
-  return await performCall()
+  return await performCall();
 }

package/nuxt.config.js

@@ -1,11 +1,11 @@
 // Node imports
-import path, { dirname } from "node:path"
-import { fileURLToPath } from "node:url"
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // Local imports
-import package_json from "./package.json"
+import package_json from "./package.json";
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export default defineNuxtConfig({
   runtimeConfig: {
@@ -16,15 +16,11 @@ export default defineNuxtConfig({
       NUXT_ROOT_PATH: __dirname,
       MODE: process.env.MODE || "CLOUD",
       PROJECT: package_json.name,
-      SITE_BRANCH:
-        process.env.NODE_ENV === "production" ? process.env.SITE_BRANCH : "",
+      SITE_BRANCH: process.env.NODE_ENV === "production" ? process.env.SITE_BRANCH : "",
     },
   },
 
-  modules: [
-    ["@pinia/nuxt", { autoImports: ["defineStore", "storeToRefs"] }],
-    "@vueuse/nuxt",
-  ],
+  modules: [["@pinia/nuxt", { autoImports: ["defineStore", "storeToRefs"] }], "@vueuse/nuxt"],
   imports: {
     scan: false,
   },
@@ -62,4 +58,4 @@ export default defineNuxtConfig({
       ],
     },
   },
-})
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.6.2",
+  "version": "10.6.3-rc.1",
   "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",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
     "@pinia/nuxt": "0.11.3",

package/scripts/generate_geode_objects.js

@@ -1,26 +1,24 @@
 /* oxlint-disable vitest/require-hook */
-import fs from "node:fs"
-import path from "node:path"
-import process from "node:process"
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
 
-const output_file = path.join(process.cwd(), "assets/geode_objects")
+const output_file = path.join(process.cwd(), "assets/geode_objects");
 
 if (fs.existsSync(output_file)) {
-  fs.unlinkSync(output_file)
+  fs.unlinkSync(output_file);
 }
 
-const files = fs.readdirSync("assets/img/geode_objects/")
-let imports = ""
-let geode_objects = "const geode_objects = {"
+const files = fs.readdirSync("assets/img/geode_objects/");
+let imports = "";
+let geode_objects = "const geode_objects = {";
 
 for (const file of files) {
-  const geode_object = file.replace(".svg", "")
-  imports +=
-    `import ${geode_object} from "@ogw_front/assets/img/geode_objects/${file}"` +
-    "\n"
-  geode_objects += `${geode_object}:{\n tooltip: "${geode_object}",\n image: ${geode_object},\n},\n`
+  const geode_object = file.replace(".svg", "");
+  imports += `import ${geode_object} from "@ogw_front/assets/img/geode_objects/${file}"\n`;
+  geode_objects += `${geode_object}:{\n tooltip: "${geode_object}",\n image: ${geode_object},\n},\n`;
 }
-geode_objects += "}\n\n export default geode_objects"
-fs.writeFileSync(output_file, `${imports}\n${geode_objects}`)
+geode_objects += "}\n\n export default geode_objects";
+fs.writeFileSync(output_file, `${imports}\n${geode_objects}`);
 
-console.log("Fichier JS créé avec succès :", output_file)
+console.log("Fichier JS créé avec succès :", output_file);

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

@@ -1,12 +1,12 @@
 // Node imports
 
 // Third party imports
-import { defineEventHandler } from "h3"
+import { defineEventHandler } from "h3";
 
 // Local imports
 
 export default defineEventHandler(() => {
-  console.log("Killing node server process")
+  console.log("Killing node server process");
   // oxlint-disable-next-line no-process-exit
-  process.exit()
-})
+  process.exit();
+});

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

@@ -1,32 +1,32 @@
 // Node imports
 
 // Third party imports
-import { createError, defineEventHandler } from "h3"
+import { createError, defineEventHandler } from "h3";
 
 // Local imports
 import {
   createPath,
   generateProjectFolderPath,
-} from "@geode/opengeodeweb-front/app/utils/local/path.js"
+} from "@geode/opengeodeweb-front/app/utils/local/path.js";
 
-import { useRuntimeConfig } from "nitropack/runtime"
+import { useRuntimeConfig } from "nitropack/runtime";
 
 export default defineEventHandler(async (event) => {
   try {
-    const config = useRuntimeConfig(event).public
-    const { PROJECT } = config
-    const projectFolderPath = generateProjectFolderPath(PROJECT)
-    await createPath(projectFolderPath)
+    const config = useRuntimeConfig(event).public;
+    const { PROJECT } = config;
+    const projectFolderPath = generateProjectFolderPath(PROJECT);
+    await createPath(projectFolderPath);
 
     return {
       statusCode: 200,
       projectFolderPath,
-    }
+    };
   } catch (error) {
-    console.log(error)
+    console.log(error);
     throw createError({
       statusCode: 500,
       statusMessage: error.message,
-    })
+    });
   }
-})
+});

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

@@ -1,37 +1,37 @@
 // Node imports
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3"
+import { createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import {
   addMicroserviceMetadatas,
   runBack,
-} from "@geode/opengeodeweb-front/app/utils/local/microservices.js"
+} from "@geode/opengeodeweb-front/app/utils/local/microservices.js";
 
-import { useRuntimeConfig } from "nitropack/runtime"
+import { useRuntimeConfig } from "nitropack/runtime";
 
 export default defineEventHandler(async (event) => {
   try {
-    const config = useRuntimeConfig(event).public
-    const { COMMAND_BACK, NUXT_ROOT_PATH } = config
-    const { args } = await readBody(event)
-    const port = await runBack(COMMAND_BACK, NUXT_ROOT_PATH, args)
+    const config = useRuntimeConfig(event).public;
+    const { COMMAND_BACK, NUXT_ROOT_PATH } = config;
+    const { args } = await readBody(event);
+    const port = await runBack(COMMAND_BACK, NUXT_ROOT_PATH, args);
     await addMicroserviceMetadatas(args.projectFolderPath, {
       type: "back",
       name: COMMAND_BACK,
       port,
-    })
+    });
 
     return {
       statusCode: 200,
       port,
-    }
+    };
   } catch (error) {
-    console.log(error)
+    console.log(error);
     throw createError({
       statusCode: 500,
       statusMessage: error.message,
-    })
+    });
   }
-})
+});

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

@@ -1,37 +1,37 @@
 // Node imports
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3"
+import { createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import {
   addMicroserviceMetadatas,
   runViewer,
-} from "@geode/opengeodeweb-front/app/utils/local/microservices.js"
+} from "@geode/opengeodeweb-front/app/utils/local/microservices.js";
 
-import { useRuntimeConfig } from "nitropack/runtime"
+import { useRuntimeConfig } from "nitropack/runtime";
 
 export default defineEventHandler(async (event) => {
   try {
-    const config = useRuntimeConfig(event).public
-    const { COMMAND_VIEWER, NUXT_ROOT_PATH } = config
-    const { args } = await readBody(event)
-    const port = await runViewer(COMMAND_VIEWER, NUXT_ROOT_PATH, args)
+    const config = useRuntimeConfig(event).public;
+    const { COMMAND_VIEWER, NUXT_ROOT_PATH } = config;
+    const { args } = await readBody(event);
+    const port = await runViewer(COMMAND_VIEWER, NUXT_ROOT_PATH, args);
     await addMicroserviceMetadatas(args.projectFolderPath, {
       type: "viewer",
       name: COMMAND_VIEWER,
       port,
-    })
+    });
 
     return {
       statusCode: 200,
       port,
-    }
+    };
   } catch (error) {
-    console.log(error)
+    console.log(error);
     throw createError({
       statusCode: 500,
       statusMessage: error.message,
-    })
+    });
   }
-})
+});

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

@@ -1,99 +1,92 @@
 // Node imports
-import fs from "node:fs"
-import path from "node:path"
+import fs from "node:fs";
+import path from "node:path";
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3"
+import { createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 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"
+} 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
+const CODE_200 = 200;
 
 export default defineEventHandler(async (event) => {
   try {
-    const body = await readBody(event)
-    const { projectFolderPath, projectName } = body
-    const extensionsConfig = extensionsConf(projectName)
+    const body = await readBody(event);
+    const { projectFolderPath, projectName } = body;
+    const extensionsConfig = extensionsConf(projectName);
 
     const extensionsArray = await Promise.all(
       Object.keys(extensionsConfig).map(async (extensionID) => {
-        const extensionPath = extensionsConfig[extensionID].path
+        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")
+        );
+        const metadataPath = path.join(unzippedExtensionPath, "metadata.json");
+        const metadataContent = await fs.promises.readFile(metadataPath, "utf8");
 
         if (!metadataContent) {
           throw createError({
             statusCode: 400,
             statusMessage: "Invalid extension file: missing metadata.json",
-          })
+          });
         }
-        const metadata = JSON.parse(metadataContent)
-        console.log("runExtensions", { metadata })
+        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",
-          })
+            statusMessage: "Invalid extension file: missing frontend JavaScript",
+          });
         }
         if (!backendExecutable) {
           throw createError({
             statusCode: 400,
             statusMessage: "Invalid extension file: missing backend executable",
-          })
+          });
         }
 
-        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 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,
-        })
+        });
         await addMicroserviceMetadatas(projectFolderPath, {
           type: "back",
           name,
           port,
-        })
+        });
         return {
           id,
           name,
           version,
           frontendContent,
           port,
-        }
+        };
       }),
-    )
+    );
 
     return {
       statusCode: CODE_200,
       extensionsArray,
-    }
+    };
   } catch (error) {
-    console.error("Error running extensions:", error)
+    console.error("Error running extensions:", error);
     throw createError({
       statusCode: 500,
       statusMessage: error.message,
-    })
+    });
   }
-})
+});