@geode/opengeodeweb-front 10.29.1 → 10.30.0-rc.10

package/internal/utils/api_fetch.js

@@ -1,78 +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,50 +1,57 @@
+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 },
+  { 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();
+  for (const [key, value] of Object.entries(params)) {
+    body.append(key, value);
+  }
   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/nuxt.config.js

@@ -27,8 +27,9 @@ export default defineNuxtConfig({
   alias: {
     "@ogw_front": path.resolve(__dirname, "app"),
     "@ogw_internal": path.resolve(__dirname, "internal"),
-    "@ogw_server": path.resolve(__dirname, "server"),
     "@ogw_tests": path.resolve(__dirname, "tests"),
+    "@ogw_shared": path.resolve(__dirname, "shared"),
+    "@ogw_server": path.resolve(__dirname, "server"),
   },
 
   // ** Global CSS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.29.1",
+  "version": "10.30.0-rc.10",
   "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",
@@ -62,6 +62,7 @@
     "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",

package/server/api/local/{project_folder_path.post.js → app/project_folder_path.post.js}

@@ -7,7 +7,7 @@ import { createError, defineEventHandler, readBody } from "h3";
 import {
   createPath,
   generateProjectFolderPath,
-} from "@geode/opengeodeweb-front/app/utils/local/path.js";
+} from "@geode/opengeodeweb-front/server/utils/path.js";
 
 export default defineEventHandler(async (event) => {
   try {

package/server/api/local/{run_back.post.js → app/run_back.post.js}

@@ -7,7 +7,7 @@ import { createError, defineEventHandler, readBody } from "h3";
 import {
   addMicroserviceMetadatas,
   runBack,
-} from "@geode/opengeodeweb-front/app/utils/local/microservices.js";
+} from "@geode/opengeodeweb-front/server/utils/microservices.js";
 
 export default defineEventHandler(async (event) => {
   try {

package/server/api/local/{run_viewer.post.js → app/run_viewer.post.js}

@@ -7,7 +7,7 @@ import { createError, defineEventHandler, readBody } from "h3";
 import {
   addMicroserviceMetadatas,
   runViewer,
-} from "@geode/opengeodeweb-front/app/utils/local/microservices.js";
+} from "@geode/opengeodeweb-front/server/utils/microservices.js";
 
 export default defineEventHandler(async (event) => {
   try {

package/server/api/{microservice → local}/extensions/upload.put.js

@@ -2,27 +2,26 @@
 import { finished, pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
 import fs from "node:fs";
-import path from "node:path";
 
 // Third party imports
 import { createError, defineEventHandler, getRequestHeaders, getRequestWebStream } from "h3";
-import StreamZip from "node-stream-zip";
 import busboy from "busboy";
-import sanitize from "sanitize-filename";
 
 // Local imports
-import { addExtensionToConf, confFolderPath } from "@geode/opengeodeweb-front/app/utils/config.js";
+import {
+  registerExtensionFile,
+  targetExtensionFilePath,
+} from "@geode/opengeodeweb-front/server/utils/app_config.js";
 
 const CODE_201 = 201;
-const FILE_SIZE_LIMIT = 107_374_182;
+const BYTES_PER_KIBIBYTE = 1024;
+const MAX_FILE_MEGABYTES = 500;
+const FILE_SIZE_LIMIT = MAX_FILE_MEGABYTES * BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE;
 
 export default defineEventHandler(async (event) => {
-  const projectName = "vease";
   const writePromises = [];
   const savedFiles = [];
 
-  const configFolderPath = confFolderPath(projectName);
-
   const busboyInstance = busboy({
     headers: getRequestHeaders(event),
     limits: {
@@ -30,6 +29,13 @@ export default defineEventHandler(async (event) => {
       files: 1,
     },
   });
+  let projectName = "";
+  busboyInstance.on("field", (name, value) => {
+    console.log(`Field ${name}: ${value}`);
+    if (name === "projectName") {
+      projectName = value;
+    }
+  });
 
   busboyInstance.on("file", (fieldname, fileStream, info) => {
     if (fieldname !== "file") {
@@ -37,57 +43,30 @@ export default defineEventHandler(async (event) => {
       fileStream.resume();
       return;
     }
-
-    const safeFilename = sanitize(info.filename);
-    const targetPath = path.join(configFolderPath, safeFilename);
-
+    const targetPath = targetExtensionFilePath(projectName, info.filename);
     const writePromise = (async () => {
       const writeStream = fs.createWriteStream(targetPath);
       await pipeline(fileStream, writeStream);
       savedFiles.push(targetPath);
       console.log("File written:", targetPath);
     })();
-
     writePromises.push(writePromise);
     fileStream.on("limit", () => busboyInstance.destroy(new Error("File too large")));
   });
 
-  busboyInstance.on("field", (name, value) => {
-    console.log(`Field ${name}: ${value}`);
-  });
-
   busboyInstance.on("filesLimit", () => busboyInstance.destroy(new Error("Too many files")));
   busboyInstance.on("partsLimit", () => busboyInstance.destroy(new Error("Too many parts")));
 
   const webStream = getRequestWebStream(event);
   Readable.fromWeb(webStream).pipe(busboyInstance);
   await finished(busboyInstance);
-
   if (writePromises.length > 0) {
     await Promise.all(writePromises);
     console.log("All disk writes completed");
   }
-
   if (savedFiles.length === 0) {
     throw createError({ statusCode: 400, message: "No file received" });
   }
-
-  await Promise.all(
-    savedFiles.map(async (file) => {
-      const StreamZipAsync = StreamZip.async;
-      const zip = new StreamZipAsync({
-        file,
-        storeEntries: true,
-      });
-      const metadataJson = await zip.entryData("metadata.json");
-      const metadata = JSON.parse(metadataJson);
-      const { id } = metadata;
-      await addExtensionToConf(projectName, {
-        extensionId: id,
-        extensionPath: file,
-      });
-    }),
-  );
-
+  await Promise.all(savedFiles.map(async (file) => await registerExtensionFile(projectName, file)));
   return { statusCode: CODE_201 };
 });

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

@@ -0,0 +1,25 @@
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setAppBaseUrl } 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 setAppBaseUrl(baseUrl);
+    console.log(`Updated APP_BASE_URL to ${baseUrl}`);
+
+    return { statusCode: 200, baseUrl };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: error.statusCode,
+      statusMessage: error.statusMessage ?? error.message,
+    });
+  }
+});

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/api/microservice/extensions/download.post.js

@@ -0,0 +1,32 @@
+// Node imports
+import { promises as fs } from "node:fs";
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import {
+  registerExtensionFile,
+  targetExtensionFilePath,
+} from "@geode/opengeodeweb-front/server/utils/app_config.js";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const body = await readBody(event);
+    const { projectName, url, extensionFileName } = body;
+    console.log({ projectName, url, extensionFileName });
+    const fileBuffer = await fetch(url).then((file) => file.arrayBuffer());
+    const filePath = targetExtensionFilePath(projectName, extensionFileName);
+    await fs.writeFile(filePath, Buffer.from(fileBuffer));
+    await registerExtensionFile(projectName, filePath);
+    return {
+      statusCode: 200,
+    };
+  } catch (error) {
+    console.error("Error downloading extension:", error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    });
+  }
+});

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

@@ -9,9 +9,9 @@ import {
   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";
+} from "@geode/opengeodeweb-front/server/utils/cleanup.js";
+import { extensionFolderPath } from "@geode/opengeodeweb-front/server/utils/path.js";
+import { removeExtensionFromConf } from "@geode/opengeodeweb-front/server/utils/app_config.js";
 
 export default defineEventHandler(async (event) => {
   try {

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

@@ -9,17 +9,18 @@ import { createError, defineEventHandler, readBody } from "h3";
 import {
   addMicroserviceMetadatas,
   runBack,
-} from "@geode/opengeodeweb-front/app/utils/local/microservices.js";
+} from "@geode/opengeodeweb-front/server/utils/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";
+} from "@geode/opengeodeweb-front/server/utils/path.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 extensionsConfig = extensionsConf(projectName);

package/server/api/serverless/{run_cloud.js → run_cloud.post.js}

@@ -6,7 +6,7 @@ import { GoogleAuth } from "google-auth-library";
 import { ServicesClient } from "@google-cloud/run";
 
 // Local imports
-import { artifactImage, requestConfig } from "@ogw_server/utils/cloud";
+import { artifactImage, requestConfig } from "@geode/opengeodeweb-front/server/utils/cloud";
 
 export default defineEventHandler(async (event) => {
   try {

package/{app/utils/config.js → server/utils/app_config.js}

@@ -4,6 +4,8 @@ import { unlink } from "node:fs";
 
 // Third party imports
 import Conf from "conf";
+import StreamZip from "node-stream-zip";
+import sanitize from "sanitize-filename";
 
 // Local imports
 
@@ -18,6 +20,12 @@ function confFolderPath(projectName) {
   return path.dirname(projectConfig.path);
 }
 
+function targetExtensionFilePath(projectName, filename) {
+  const safeFilename = sanitize(filename);
+  const targetPath = path.join(confFolderPath(projectName), safeFilename);
+  return targetPath;
+}
+
 function extensionsConf(projectName) {
   const projectConfig = projectConf(projectName);
   if (!projectConfig.has("extensions")) {
@@ -51,11 +59,28 @@ function extensionPathFromConf(projectName, extensionId) {
   return projectConfig.get(`extensions.${extensionId}.path`);
 }
 
+async function registerExtensionFile(projectName, file) {
+  const StreamZipAsync = StreamZip.async;
+  const zip = new StreamZipAsync({
+    file,
+    storeEntries: true,
+  });
+  const metadataJson = await zip.entryData("metadata.json");
+  const metadata = JSON.parse(metadataJson);
+  const { id } = metadata;
+  addExtensionToConf(projectName, {
+    extensionId: id,
+    extensionPath: file,
+  });
+}
+
 export {
+  addExtensionToConf,
   confFolderPath,
-  projectConf,
+  extensionPathFromConf,
   extensionsConf,
-  addExtensionToConf,
+  projectConf,
+  registerExtensionFile,
   removeExtensionFromConf,
-  extensionPathFromConf,
+  targetExtensionFilePath,
 };

package/{app/utils/local → server/utils}/path.js

@@ -8,7 +8,7 @@ import { setTimeout } from "node:timers/promises";
 import { v4 as uuidv4 } from "uuid";
 
 // Local imports
-import { appMode } from "./app_mode.js";
+import { appMode } from "@geode/opengeodeweb-front/shared/app_mode.js";
 import { commandExistsSync } from "./scripts.js";
 
 function findExecutableInDir(baseDir, execName, osExecutableName) {

package/{app/utils/local → server/utils}/scripts.js

@@ -9,7 +9,8 @@ import readline from "node:readline";
 import { getPort } from "get-port-please";
 
 // Local imports
-import { appMode } from "./app_mode.js";
+import { appMode } from "@geode/opengeodeweb-front/shared/app_mode.js";
+import { setAppBaseUrl } from "@geode/opengeodeweb-front/shared/scripts.js";
 
 const BYTES_PER_KIBIBYTE = 1024;
 const MAX_ERROR_BUFFER_KIBIBYTES = 64;
@@ -164,7 +165,9 @@ async function runBrowser(scriptName) {
       PORT: port,
     },
   });
-  return await waitNuxt(nuxtProcess);
+  await waitNuxt(nuxtProcess);
+  await setAppBaseUrl(`http://localhost:${port}`);
+  return port;
 }
 
 export { commandExistsSync, getAvailablePort, runBrowser, waitForReady };

package/server/utils/server_config.js

@@ -0,0 +1,32 @@
+import { createStorage, prefixStorage } from "unstorage";
+
+const storage = createStorage();
+const config = prefixStorage(storage, "config");
+
+function getAppBaseUrl() {
+  return config.getItem("APP_BASE_URL");
+}
+function setAppBaseUrl(baseUrl) {
+  return config.setItem("APP_BASE_URL", baseUrl);
+}
+function getBackBaseUrl() {
+  return config.getItem("BACK_BASE_URL");
+}
+function setBackBaseUrl(baseUrl) {
+  return config.setItem("BACK_BASE_URL", baseUrl);
+}
+function getViewerBaseUrl() {
+  return config.getItem("VIEWER_BASE_URL");
+}
+function setViewerBaseUrl(baseUrl) {
+  return config.setItem("VIEWER_BASE_URL", baseUrl);
+}
+
+export {
+  getAppBaseUrl,
+  setAppBaseUrl,
+  getBackBaseUrl,
+  getViewerBaseUrl,
+  setBackBaseUrl,
+  setViewerBaseUrl,
+};