@geode/opengeodeweb-front 10.30.0-rc.8 → 10.30.0

package/internal/utils/api_fetch.js

@@ -1,79 +1,52 @@
-import _ from "lodash";
+import { endRequestLog, startRequestLog } from "@ogw_front/utils/log";
+import { fetchSchema } from "@ogw_shared/utils/fetch_schema";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
-import { validate_schema } from "@ogw_front/utils/validate_schema";
-
-const ERROR_400 = 400;
 
 export function api_fetch(
   microservice,
-  { schema, params, headers },
+  { schema, params = {}, headers = {} },
   { request_error_function, response_function, response_error_function, timeout } = {},
 ) {
   console.log("[API] Fetching", microservice.base_url);
   const feedbackStore = useFeedbackStore();
-
-  const body = params || {};
-
-  const { valid, error: schema_error } = validate_schema(schema, body);
-
-  if (!valid) {
-    if (process.env.NODE_ENV !== "production") {
-      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}`);
-  }
-
   microservice.start_request();
 
-  const method = schema.methods.find((methodItem) => methodItem !== "OPTIONS");
-  const request_options = {
-    method,
-    headers,
-  };
-  if (!_.isEmpty(body)) {
-    request_options.body = body;
-  }
-
-  if (schema.max_retry) {
-    request_options.max_retry = schema.max_retry;
-  }
-
-  function performFetch() {
-    return $fetch(schema.$id, {
+  const requestStartingTime = startRequestLog(microservice, schema);
+  return fetchSchema(
+    {
+      schema,
       baseURL: microservice.base_url,
-      ...request_options,
-      onRequestError({ error }) {
+      params,
+      headers,
+      max_retry: schema.max_retry,
+      timeout,
+    },
+    {
+      request_error_function(error) {
         microservice.stop_request();
         feedbackStore.add_error(error.code, schema.$id, error.message, error.stack);
         if (request_error_function) {
           request_error_function(error);
         }
       },
-      onResponse({ response }) {
-        if (response.ok) {
-          microservice.stop_request();
-          if (response_function) {
-            response_function(response._data);
-          }
+      response_function(data) {
+        endRequestLog(microservice, schema, requestStartingTime);
+        microservice.stop_request();
+        if (response_function) {
+          response_function(data);
         }
       },
-      onResponseError({ response }) {
+      response_error_function(response) {
         microservice.stop_request();
         feedbackStore.add_error(response.status, schema.$id, response.name, response.description);
         if (response_error_function) {
           response_error_function(response);
         }
       },
-    });
-  }
-
-  if (timeout > 0) {
-    return pTimeout(performCall(), {
-      milliseconds: timeout,
-      message: `${schema.$id}: Timed out after ${timeout}ms`,
-    });
-  }
-
-  return performFetch();
+      validation_error_function({ code, name, error }) {
+        microservice.stop_request();
+        feedbackStore.add_error(code, schema.$id, name, error);
+      },
+    },
+  );
 }

package/internal/utils/upload_file.js

@@ -1,14 +1,16 @@
+import { fetchRaw } from "@ogw_shared/utils/fetch_raw.js";
 import { useFeedbackStore } from "@ogw_front/stores/feedback.js";
 
-async function upload_file(
+function upload_file(
   microservice,
-  { route, file, params = {} },
+  { schema, file, params = {} },
   { request_error_function, response_function, response_error_function } = {},
 ) {
-  console.log("[UPLOAD_FILE] Uploading file", { route, file });
+  console.log("[UPLOAD_FILE] Uploading file", { schema, file });
   const feedbackStore = useFeedbackStore();
+
   if (!(file instanceof File)) {
-    throw new Error("file must be a instance of File");
+    return Promise.reject(new Error("file must be an instance of File"));
   }
 
   const body = new FormData();
@@ -17,37 +19,39 @@ async function upload_file(
   }
   body.append("file", file);
 
-  const request_options = {
-    method: "PUT",
-    body,
-  };
   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);
-      if (request_error_function) {
-        request_error_function(error);
-      }
+  const route = schema.$id;
+
+  return fetchRaw(
+    {
+      route,
+      method: schema.methods.find((method) => method !== "OPTIONS"),
+      params: body,
+      baseURL: microservice.base_url,
     },
-    onResponse({ response }) {
-      if (response.ok) {
+    {
+      request_error_function(error) {
+        microservice.stop_request();
+        feedbackStore.add_error(error.code, route, error.message, error.stack);
+        if (request_error_function) {
+          request_error_function(error);
+        }
+      },
+      response_function(data) {
         microservice.stop_request();
         if (response_function) {
-          response_function(response);
+          response_function(data);
         }
-      }
-    },
-    onResponseError({ response }) {
-      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) {
+        microservice.stop_request();
+        feedbackStore.add_error(response.status, route, response.name, response.description);
+        if (response_error_function) {
+          response_error_function(response);
+        }
+      },
     },
-  });
+  );
 }
 
 export { upload_file };

package/internal/utils/viewer_call.js

@@ -1,6 +1,10 @@
+// Third party imports
 import pTimeout from "p-timeout";
+
+// Local imports
+import { endRequestLog, startRequestLog } from "@ogw_front/utils/log";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
-import { validate_schema } from "@ogw_front/utils/validate_schema";
+import { validate_schema } from "@ogw_shared/utils/validate_schema";
 
 const ERROR_400 = 400;
 
@@ -28,9 +32,10 @@ export function viewer_call(
       return;
     }
     microservice.start_request();
-
+    const requestStart = startRequestLog(microservice, schema);
     try {
       const value = await client.getConnection().getSession().call(schema.$id, [params]);
+      endRequestLog(microservice, schema, requestStart);
       if (response_function) {
         await response_function(value);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.30.0-rc.8",
+  "version": "10.30.0",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -34,12 +34,12 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "next",
-    "@geode/opengeodeweb-viewer": "next",
+    "@geode/opengeodeweb-back": "latest",
+    "@geode/opengeodeweb-viewer": "latest",
     "@google-cloud/run": "3.2.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
-    "@pinia/nuxt": "0.11.3",
+    "@pinia/nuxt": "1.0.1",
     "@types/node": "22.15.3",
     "@vueuse/components": "13.1.0",
     "@vueuse/nuxt": "13.1.0",
@@ -54,37 +54,38 @@
     "js-file-download": "0.4.12",
     "jszip": "3.10.1",
     "node-stream-zip": "1.15.0",
-    "nuxt": "4.2.2",
+    "nuxt": "4.5.1",
     "p-timeout": "7.0.1",
-    "pinia": "3.0.4",
+    "pinia": "4.0.2",
     "rimraf": "6.1.3",
     "rxjs": "7.8.2",
     "sanitize-filename": "1.6.3",
     "sass": "1.87.0",
     "semver": "7.7.1",
+    "unstorage": "1.17.5",
     "uuid": "11.1.0",
     "vuetify": "3.12.5",
     "vuetify-nuxt-module": "0.18.7",
-    "ws": "8.18.3",
+    "ws": "8.21.2",
     "wslink": "1.12.4"
   },
   "devDependencies": {
-    "@nuxt/test-utils": "3.21.0",
-    "@pinia/testing": "1.0.3",
-    "@vitejs/plugin-vue": "6.0.4",
-    "@vue/test-utils": "2.4.6",
+    "@nuxt/test-utils": "4.1.0",
+    "@pinia/testing": "2.0.1",
+    "@vitejs/plugin-vue": "6.0.8",
+    "@vue/test-utils": "2.4.11",
     "happy-dom": "20.0.11",
     "msw": "2.11.1",
     "playwright-core": "1.52.0",
     "resize-observer-polyfill": "1.5.1",
     "unplugin-auto-import": "20.0.0",
-    "vite": "7.3.1",
-    "vite-plugin-vuetify": "2.1.1",
-    "vitest": "4.0.15",
-    "vitest-environment-nuxt": "1.0.1",
+    "vite": "8.2.0",
+    "vite-plugin-vuetify": "2.1.3",
+    "vitest": "4.1.10",
+    "vitest-environment-nuxt": "2.0.0",
     "vitest-indexeddb": "0.0.1"
   },
   "overrides": {
-    "vue": "latest"
+    "vue": "3.5.40"
   }
 }

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

@@ -0,0 +1,72 @@
+// Node imports
+import fs from "node:fs";
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import {
+  addMicroserviceMetadatas,
+  runExtension,
+} from "@geode/opengeodeweb-front/server/utils/microservices.js";
+import {
+  extensionBackendPath,
+  extensionFolderPath,
+} from "@geode/opengeodeweb-front/server/utils/path.js";
+import {
+  readExtensionFrontend,
+  readExtensionMetadata,
+} from "@geode/opengeodeweb-front/server/utils/extension.js";
+import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.js";
+import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.js";
+
+export default defineEventHandler(async (event) => {
+  try {
+    console.log("NITRO: runExtensions", event);
+    const { projectFolderPath, projectName } = await readBody(event);
+    const extensionsConfig = extensionsConf(projectName);
+    const extensionsArray = await Promise.all(
+      Object.keys(extensionsConfig).map(async (extensionId) => {
+        const extensionPath = extensionsConfig[extensionId].path;
+        const unzippedExtensionPath = await unzipFile(
+          extensionPath,
+          extensionFolderPath(projectFolderPath, extensionId),
+        );
+        const { id, name, version, backendExecutable, frontendFile } =
+          await readExtensionMetadata(unzippedExtensionPath);
+        const frontendContent = await readExtensionFrontend(
+          unzippedExtensionPath,
+          frontendFile,
+          id,
+        );
+        fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
+        const port = await runExtension(id, backendExecutable, unzippedExtensionPath, {
+          projectFolderPath,
+        });
+        await addMicroserviceMetadatas(projectFolderPath, {
+          type: "back",
+          name,
+          port,
+        });
+        return {
+          id,
+          name,
+          version,
+          frontendContent,
+          port,
+        };
+      }),
+    );
+
+    return {
+      statusCode: 200,
+      extensionsArray,
+    };
+  } catch (error) {
+    console.error("Error running extensions:", error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    });
+  }
+});

package/server/api/{microservice → local}/extensions/run.post.js

@@ -1,6 +1,5 @@
 // Node imports
 import fs from "node:fs";
-import path from "node:path";
 
 // Third party imports
 import { createError, defineEventHandler, readBody } from "h3";
@@ -11,20 +10,21 @@ import {
   runBack,
 } from "@geode/opengeodeweb-front/server/utils/microservices.js";
 import {
-  executableName,
+  extensionBackendPath,
   extensionFolderPath,
-  extensionFrontendPath,
 } from "@geode/opengeodeweb-front/server/utils/path.js";
+import {
+  readExtensionFrontend,
+  readExtensionMetadata,
+} from "@geode/opengeodeweb-front/server/utils/extension.js";
 import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.js";
 import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.js";
 
 export default defineEventHandler(async (event) => {
   try {
     console.log("NITRO: runExtensions", event);
-    const body = await readBody(event);
-    const { projectFolderPath, projectName } = body;
+    const { projectFolderPath, projectName } = await readBody(event);
     const extensionsConfig = extensionsConf(projectName);
-
     const extensionsArray = await Promise.all(
       Object.keys(extensionsConfig).map(async (extensionId) => {
         const extensionPath = extensionsConfig[extensionId].path;
@@ -32,50 +32,14 @@ export default defineEventHandler(async (event) => {
           extensionPath,
           extensionFolderPath(projectFolderPath, extensionId),
         );
-        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 { 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",
-          });
-        }
-
-        const frontendFilePath = await extensionFrontendPath(
+        const { id, name, version, backendExecutable, frontendFile } =
+          await readExtensionMetadata(unzippedExtensionPath);
+        const frontendContent = await readExtensionFrontend(
           unzippedExtensionPath,
           frontendFile,
-          path.resolve(),
           id,
         );
-
-        console.log("runExtensions", { frontendFilePath });
-        const frontendContent = await fs.promises.readFile(frontendFilePath, "utf8");
-
-        const backendExecutablePath = path.join(
-          unzippedExtensionPath,
-          executableName(backendExecutable),
-        );
-        console.log("runExtensions", { backendExecutablePath });
-        fs.chmodSync(backendExecutablePath, "755");
+        fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
         const port = await runBack(backendExecutable, unzippedExtensionPath, {
           projectFolderPath,
         });

package/server/api/microservice/app/set_back_base_url.post.js

@@ -0,0 +1,22 @@
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setBackBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.js";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const { baseUrl } = await readBody(event);
+    if (!baseUrl) {
+      throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
+    }
+    await setBackBaseUrl(baseUrl);
+    return { statusCode: 200, baseUrl };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: error.statusCode,
+      statusMessage: error.message,
+    });
+  }
+});

package/server/api/microservice/app/set_viewer_base_url.post.js

@@ -0,0 +1,22 @@
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setViewerBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.js";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const { baseUrl } = await readBody(event);
+    if (!baseUrl) {
+      throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
+    }
+    await setViewerBaseUrl(baseUrl);
+    return { statusCode: 200, baseUrl };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: error.statusCode,
+      statusMessage: error.message,
+    });
+  }
+});

package/server/utils/cloud.js

@@ -5,6 +5,8 @@ import { google } from "googleapis";
 
 // Local imports
 
+const LOCATIONS_DIR = "/etc/nginx/locations";
+
 async function artifactImage(parent, authClient) {
   const projectName = process.env.PROJECT;
   const registry = google.artifactregistry({
@@ -92,4 +94,108 @@ function requestConfig(parent, image, email, projectName) {
   };
 }
 
-export { artifactImage, requestConfig };
+function addSupervisorProgram(name, command, executableArgs) {
+  const conf = `
+[program:${name}]
+command=${command} ${executableArgs.join(" ")}
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+`;
+  const confPath = path.join("/etc/supervisor/conf.d", `${name}.conf`);
+  fs.writeFileSync(confPath, conf);
+  execFileSync("supervisorctl", ["reread"]);
+  execFileSync("supervisorctl", ["update"]);
+  const stdout = execFileSync("supervisorctl", ["start", name]);
+  console.log("addSupervisorProgram", stdout);
+}
+
+function buildLocationBlock(routePath, port) {
+  if (!routePath.startsWith("/") || !routePath.endsWith("/")) {
+    throw new Error(`routePath must start and end with '/', got: ${routePath}`);
+  }
+  const methods = "GET, POST, PUT, DELETE, PATCH, OPTIONS";
+  const limitMethods = methods
+    .split(",")
+    .map((method) => method.trim())
+    .filter((method) => method !== "OPTIONS")
+    .join(" ");
+
+  return `# ====================== ${routePath} location ======================
+location ~ "^${routePath}" {
+  if ($request_method = 'OPTIONS') {
+    add_header 'Access-Control-Allow-Origin'      $allow_origin always;
+    add_header 'Access-Control-Allow-Credentials' 'true' always;
+    add_header 'Access-Control-Allow-Methods'     '${methods}' always;
+    add_header 'Access-Control-Allow-Headers'     'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,X-CSRF-Token' always;
+    add_header 'Access-Control-Max-Age'           1728000 always;
+    add_header 'Content-Type'                     'text/plain; charset=utf-8';
+    add_header 'Content-Length'                   0;
+    return 204;
+  }
+ 
+  limit_except ${limitMethods} { deny all; }
+ 
+  add_header 'Access-Control-Allow-Origin'      $allow_origin always;
+  add_header 'Access-Control-Allow-Credentials' 'true' always;
+  add_header 'Access-Control-Allow-Methods'     '${methods}' always;
+  add_header 'Access-Control-Allow-Headers'     'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,X-CSRF-Token' always;
+  add_header 'Access-Control-Expose-Headers'    'Content-Length,Content-Range' always;
+  add_header 'Vary'                             'Origin' always;
+ 
+  rewrite "^${routePath}(.*)" /$1 break;
+  proxy_pass http://localhost:${port};
+  proxy_http_version 1.1;
+  proxy_set_header Host $host;
+  proxy_set_header X-Real-IP $remote_addr;
+  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+  proxy_set_header X-Forwarded-Proto $scheme;
+}
+`;
+}
+
+function nginxConfigFile(name) {
+  return path.join(LOCATIONS_DIR, `${name}.conf`);
+}
+
+function nginxReload() {
+  execFileSync("nginx", ["-t"]);
+  execFileSync("nginx", ["-s", "reload"]);
+}
+
+function addNginxLocation(name, port) {
+  fs.mkdirSync(LOCATIONS_DIR, { recursive: true });
+  const filePath = nginxConfigFile(name);
+  if (fs.existsSync(filePath)) {
+    throw new Error(`Location '${name}' already exists at ${filePath}`);
+  }
+  fs.writeFileSync(filePath, buildLocationBlock(`/${name}/`, port));
+  try {
+    nginxReload();
+  } catch (error) {
+    fs.unlinkSync(filePath);
+    throw error;
+  }
+  return filePath;
+}
+
+function removeNginxLocation(name) {
+  const filePath = filePathFor(name);
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  fs.unlinkSync(filePath);
+  nginxReload();
+  return true;
+}
+
+export {
+  addNginxLocation,
+  addSupervisorProgram,
+  artifactImage,
+  removeNginxLocation,
+  requestConfig,
+};

package/server/utils/extension.js

@@ -0,0 +1,50 @@
+// Node imports
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+// Third party imports
+import { createError } from "h3";
+
+// Local imports
+import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.js";
+
+async function readExtensionMetadata(unzippedExtensionPath) {
+  const metadataPath = path.join(unzippedExtensionPath, "metadata.json");
+  const metadataContent = await fs.readFile(metadataPath, "utf8");
+  if (!metadataContent) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid extension file: missing metadata.json",
+    });
+  }
+  const metadata = JSON.parse(metadataContent);
+  console.log("readExtensionMetadata", { metadata });
+  if (!metadata.frontendFile) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid extension file: missing frontend JavaScript",
+    });
+  }
+  if (!metadata.backendExecutable) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid extension file: missing backend executable",
+    });
+  }
+
+  return metadata;
+}
+
+async function readExtensionFrontend(unzippedExtensionPath, frontendFile, id) {
+  console.log("readExtensionFrontend", { id });
+  const frontendFilePath = await extensionFrontendPath(
+    unzippedExtensionPath,
+    frontendFile,
+    path.resolve(),
+    id,
+  );
+  console.log("readExtensionFrontend", { frontendFilePath });
+  return fs.readFile(frontendFilePath, "utf8");
+}
+
+export { readExtensionFrontend, readExtensionMetadata };