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

package/server/utils/microservices.js

@@ -7,6 +7,7 @@ import path from "node:path";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
 
 // Local imports
+import { addNginxLocation, addSupervisorProgram } from "./cloud.js";
 import { getAvailablePort, waitForReady } from "./scripts.js";
 import { microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
 import { executablePath } from "./path.js";
@@ -57,33 +58,11 @@ function isPortInUseError(errorMessage) {
 }
 
 async function runBack(execName, execPath, args = {}, attempts = 0) {
-  const { projectFolderPath } = args;
-  if (!projectFolderPath) {
-    throw new Error("projectFolderPath is required");
-  }
-  let { uploadFolderPath } = args;
-  if (!uploadFolderPath) {
-    uploadFolderPath = path.join(projectFolderPath, "uploads");
-  }
   try {
     const port = await getAvailablePort();
-    const backArgs = [
-      "--port",
-      String(port),
-      "--project_folder_path",
-      projectFolderPath,
-      "--upload_folder_path",
-      uploadFolderPath,
-      "--allowed_origins",
-      "http://localhost:*",
-      "--timeout",
-      "0",
-    ];
-    if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
-      backArgs.push("--debug");
-    }
-    console.log("runBack", execPath, execName, backArgs);
-    await runScript(execPath, execName, backArgs, "Serving Flask app");
+    const executableArgs = backArgs(args, port);
+    console.log("runBack", execPath, execName, executableArgs);
+    await runScript(execPath, execName, executableArgs, "Serving Flask app");
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
@@ -129,6 +108,52 @@ async function runViewer(execName, execPath, args = {}, attempts = 0) {
   }
 }
 
+function backArgs(args, port) {
+  const { projectFolderPath } = args;
+  if (!projectFolderPath) {
+    throw new Error("projectFolderPath is required");
+  }
+  const uploadFolderPath = args.uploadFolderPath || path.join(projectFolderPath, "uploads");
+  const executableArgs = [
+    "--port",
+    String(port),
+    "--project_folder_path",
+    projectFolderPath,
+    "--upload_folder_path",
+    uploadFolderPath,
+    "--allowed_origins",
+    "http://localhost:*",
+    "--timeout",
+    "0",
+  ];
+  if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
+    executableArgs.push("--debug");
+  }
+  return executableArgs;
+}
+
+async function runExtension(extensionId, execName, execPath, args = {}, attempts = 0) {
+  try {
+    const port = await getAvailablePort();
+    const executableArgs = backArgs(args, port);
+    const command = executablePath(execPath, execName);
+    console.log("runExtension", execPath, execName, executableArgs);
+    addSupervisorProgram(extensionId, command, executableArgs);
+    addNginxLocation(extensionId, port);
+    return port;
+  } catch (error) {
+    if (!isPortInUseError(error)) {
+      console.log("runBack error", error);
+      throw error;
+    }
+    if (attempts <= MAX_PORT_RETRIES) {
+      console.log("Retrying runExtension on conflicting port", port);
+      const port = await runExtension(extensionId, execName, execPath, args, attempts + 1);
+      return port;
+    }
+  }
+}
+
 function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
   const microservices = projectMicroservices(projectFolderPath);
   if (serviceObj.type === "back") {
@@ -147,4 +172,4 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
   );
 }
 
-export { addMicroserviceMetadatas, runBack, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runViewer };

package/server/utils/path.js

@@ -138,8 +138,18 @@ async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPa
   throw new Error(`Failed to find ${unzippedfrontendFilePath}`);
 }
 
+function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
+  const backendExecutablePath = path.join(
+    unzippedExtensionPath,
+    executableName(backendExecutableName),
+  );
+  console.log("runExtensions", { backendExecutablePath });
+  return backendExecutablePath;
+}
+
 export {
   createPath,
+  extensionBackendPath,
   extensionFrontendPath,
   extensionFolderPath,
   executablePath,

package/server/utils/server_config.js

@@ -1,30 +1,24 @@
-import { useStorage } from "#imports";
+import { createStorage, prefixStorage } from "unstorage";
+
+const storage = createStorage();
+const config = prefixStorage(storage, "config");
 
-function getConfig() {
-  return useStorage("config");
-}
 function getAppBaseUrl() {
-  const config = getConfig();
   return config.getItem("APP_BASE_URL");
 }
 function setAppBaseUrl(baseUrl) {
-  const config = getConfig();
   return config.setItem("APP_BASE_URL", baseUrl);
 }
 function getBackBaseUrl() {
-  const config = getConfig();
   return config.getItem("BACK_BASE_URL");
 }
 function setBackBaseUrl(baseUrl) {
-  const config = getConfig();
   return config.setItem("BACK_BASE_URL", baseUrl);
 }
 function getViewerBaseUrl() {
-  const config = getConfig();
   return config.getItem("VIEWER_BASE_URL");
 }
 function setViewerBaseUrl(baseUrl) {
-  const config = getConfig();
   return config.setItem("VIEWER_BASE_URL", baseUrl);
 }
 

package/shared/scripts.js

@@ -3,16 +3,54 @@
 // Third party imports
 
 // Local imports
+import { fetchSchema } from "./utils/fetch_schema.js";
 
-function setAppBaseUrl(baseUrl) {
-  console.log(`Setting APP_BASE_URL to ${baseUrl}`);
-  return fetch(`${baseUrl}/api/microservice/app/set_app_base_url`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
+function setAppBaseUrl(appBaseUrl) {
+  console.log("[API] setAppBaseUrl", appBaseUrl);
+  const schema = {
+    $id: "/api/microservice/app/set_app_base_url",
+    methods: ["POST"],
+    type: "object",
+    properties: {
+      baseUrl: { type: "string" },
     },
-    body: JSON.stringify({ baseUrl }),
-  });
+    required: ["baseUrl"],
+    additionalProperties: false,
+  };
+  const params = { baseUrl: appBaseUrl };
+  return fetchSchema({ schema, params, baseURL: appBaseUrl });
 }
 
-export { setAppBaseUrl };
+function setBackBaseUrl(appBaseUrl, backBaseUrl) {
+  console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
+  const schema = {
+    $id: "/api/microservice/app/set_back_base_url",
+    methods: ["POST"],
+    type: "object",
+    properties: {
+      baseUrl: { type: "string" },
+    },
+    required: ["baseUrl"],
+    additionalProperties: false,
+  };
+  const params = { baseUrl: backBaseUrl };
+  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+}
+
+function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
+  console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
+  const schema = {
+    $id: "/api/microservice/app/set_viewer_base_url",
+    methods: ["POST"],
+    type: "object",
+    properties: {
+      baseUrl: { type: "string" },
+    },
+    required: ["baseUrl"],
+    additionalProperties: false,
+  };
+  const params = { baseUrl: viewerBaseUrl };
+  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+}
+
+export { setAppBaseUrl, setBackBaseUrl, setViewerBaseUrl };

package/shared/utils/fetch_raw.js

@@ -1,4 +1,5 @@
 // Third party imports
+import { $fetch } from "ofetch";
 import _ from "lodash";
 import pTimeout from "p-timeout";
 

package/shared/utils/response_handlers/load.js

@@ -0,0 +1,74 @@
+function getFileExtension(filename) {
+  return filename.slice(filename.lastIndexOf(".") + 1);
+}
+
+function selectGeodeObject(objectMap) {
+  const objectKeys = Object.keys(objectMap);
+  if (objectKeys.length === 0) {
+    return undefined;
+  }
+  if (objectKeys.length === 1 && objectMap[objectKeys[0]].is_loadable > 0) {
+    return objectKeys[0];
+  }
+
+  const highestLoadScore = Math.max(...objectKeys.map((key) => objectMap[key].is_loadable));
+  if (highestLoadScore <= 0) {
+    return undefined;
+  }
+
+  const bestScoreObjects = objectKeys.filter(
+    (key) => objectMap[key].is_loadable === highestLoadScore,
+  );
+  if (bestScoreObjects.length === 1) {
+    return bestScoreObjects[0];
+  }
+
+  const highestPriority = Math.max(
+    ...bestScoreObjects.map((key) => objectMap[key].object_priority ?? -Infinity),
+  );
+  const bestPriorityObjects = bestScoreObjects.filter(
+    (key) => objectMap[key].object_priority === highestPriority,
+  );
+  if (highestPriority !== -Infinity && bestPriorityObjects.length === 1) {
+    return bestPriorityObjects[0];
+  }
+
+  return undefined;
+}
+
+function intersectAllowedObjects(allowedObjectsList) {
+  const allKeys = [...new Set(allowedObjectsList.flatMap((object) => Object.keys(object)))];
+  const commonKeys = allKeys.filter((key) => allowedObjectsList.every((object) => key in object));
+
+  const mergedAllowedObjects = {};
+  for (const key of commonKeys) {
+    const loadScores = allowedObjectsList.map((object) => object[key].is_loadable);
+    const priorities = allowedObjectsList
+      .map((object) => object[key].object_priority)
+      .filter((priority) => priority !== undefined);
+
+    mergedAllowedObjects[key] = { is_loadable: Math.min(...loadScores) };
+    if (priorities.length > 0) {
+      mergedAllowedObjects[key].object_priority = Math.max(...priorities);
+    }
+  }
+
+  return { commonKeys, allKeys, mergedAllowedObjects };
+}
+
+function resolveAllowedObjects(filenames, allowedObjectsList) {
+  const { commonKeys, allKeys, mergedAllowedObjects } = intersectAllowedObjects(allowedObjectsList);
+
+  const multipleFilesNoCommon =
+    filenames.length > 1 && allKeys.length > 0 && commonKeys.length === 0;
+
+  const selectedGeodeObject = selectGeodeObject(mergedAllowedObjects);
+
+  return {
+    mergedAllowedObjects,
+    multipleFilesNoCommon,
+    selectedGeodeObject,
+  };
+}
+
+export { resolveAllowedObjects, getFileExtension };

package/tests/unit/composables/project_manager.nuxt.test.js

@@ -8,6 +8,12 @@ import { exportProject, importProject } from "@ogw_front/composables/project_man
 import { appMode } from "@ogw_shared/app_mode";
 import { setupActivePinia } from "@ogw_tests/utils";
 
+import { $fetch } from "ofetch";
+
+vi.mock(import("ofetch"), () => ({
+  $fetch: vi.fn(),
+}));
+
 // Constants
 const PANEL_WIDTH = 300;
 const Z_SCALE = 1.5;
@@ -141,7 +147,12 @@ const hybridViewerStoreMock = {
 };
 
 // MOCKS
-vi.stubGlobal("$fetch", vi.fn().mockResolvedValue({ snapshot: snapshotMock }));
+$fetch.mockImplementation((route, options) => {
+  const data = { snapshot: snapshotMock };
+  // oxlint-disable-next-line eslint/id-length
+  options.onResponse?.({ response: { ok: true, _data: data } });
+  return Promise.resolve(data);
+});
 vi.mock(import("@ogw_internal/utils/viewer_call"), () => ({
   viewer_call: viewer_call_mock_fn,
 }));

package/tests/unit/composables/upload_file.nuxt.test.js

@@ -22,7 +22,7 @@ describe("upload_file", () => {
     const backStore = useBackStore();
     const file = "toto";
 
-    await expect(backStore.upload(file)).rejects.toThrow("file must be a instance of File");
+    await expect(backStore.upload(file)).rejects.toThrow("file must be an instance of File");
   });
 
   test("onResponse", async () => {
@@ -36,7 +36,7 @@ describe("upload_file", () => {
     let response_value = "";
     await backStore.upload(file, {
       response_function: (response) => {
-        response_value = response._data.test;
+        response_value = response.test;
       },
     });
     expect(feedbackStore.feedbacks).toHaveLength(ZERO);

package/tests/unit/stores/cloud.nuxt.test.js

@@ -1,6 +1,6 @@
 // Third party imports
 import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
-import { registerEndpoint } from "@nuxt/test-utils/runtime";
+import { $fetch } from "ofetch";
 
 // Local imports
 import { Status } from "@ogw_front/utils/status";
@@ -8,9 +8,12 @@ import { setupActivePinia } from "@ogw_tests/utils";
 import { useCloudStore } from "@ogw_front/stores/cloud";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 
+vi.mock(import("ofetch"), () => ({
+  $fetch: vi.fn(),
+}));
+
 // CONSTANTS
 const PROJECT = "project";
-const STATUS_500 = 500;
 
 function setupConfig() {
   const config = useRuntimeConfig();
@@ -31,28 +34,23 @@ describe("cloud store", () => {
 
   describe("actions", () => {
     describe("launch", () => {
-      const postFakeCall = vi.fn();
+      beforeEach(() => {
+        $fetch.mockReset();
+      });
 
       test("successful launch", async () => {
         setupConfig();
         const cloudStore = useCloudStore();
         const feedbackStore = useFeedbackStore();
 
-        registerEndpoint("https://localhost:443/server/api/serverless/run_cloud", {
-          method: "POST",
-          handler: postFakeCall,
+        $fetch.mockImplementation((route, options) => {
+          const data = { url: "test.com" };
+          // oxlint-disable-next-line eslint/id-length
+          options.onResponse?.({ response: { ok: true, _data: data } });
+          return Promise.resolve(data);
         });
 
-        registerEndpoint("https://test.com:443/server/api/microservice/app/set_app_base_url", {
-          method: "POST",
-          handler: () => console.log("coucou from endpoint"),
-        });
-
-        postFakeCall.mockReturnValue({
-          url: "test.com",
-        });
-        const email = "noreply@example.com";
-        await cloudStore.launch(email);
+        await cloudStore.launch("noreply@example.com");
 
         expect(cloudStore.status).toBe(Status.CONNECTED);
         expect(feedbackStore.server_error).toBe(false);
@@ -63,19 +61,18 @@ describe("cloud store", () => {
         const cloudStore = useCloudStore();
         const feedbackStore = useFeedbackStore();
 
-        registerEndpoint("https://localhost:443/server/api/serverless/run_cloud", {
-          method: "POST",
-          handler: postFakeCall,
-        });
+        const error = createError({ statusCode: 500, statusMessage: "500 Internal Server Error" });
 
-        postFakeCall.mockImplementation(() => {
-          throw createError({
-            status: STATUS_500,
-            statusMessage: "Internal Server Error",
+        $fetch.mockImplementation((route, options) => {
+          options.onResponseError?.({
+            response: { status: 500, name: "Error", description: "500 Internal Server Error" },
           });
+          return Promise.reject(error);
         });
-        const email = "noreply@example.com";
-        await expect(cloudStore.launch(email)).rejects.toThrow("500 Internal Server Error");
+
+        await expect(cloudStore.launch("noreply@example.com")).rejects.toThrow(
+          "500 Internal Server Error",
+        );
 
         expect(cloudStore.status).toBe(Status.NOT_CONNECTED);
         expect(feedbackStore.server_error).toBe(true);

package/tests/unit/stores/infra.nuxt.test.js

@@ -1,6 +1,6 @@
 // Third party imports
 import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
-import { registerEndpoint } from "@nuxt/test-utils/runtime";
+import { $fetch } from "ofetch";
 
 // Local imports
 import { Status } from "@ogw_front/utils/status";
@@ -10,6 +10,10 @@ import { useBackStore } from "@ogw_front/stores/back";
 import { useInfraStore } from "@ogw_front/stores/infra";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
+vi.mock(import("ofetch"), () => ({
+  $fetch: vi.fn(),
+}));
+
 // Mock navigator.locks API
 const mockLockRequest = vi
   .fn()
@@ -291,11 +295,14 @@ describe("infra store", () => {
 
       infraStore.app_mode = appMode.CLOUD;
       const url = "test.com";
-      registerEndpoint("https://localhost:443/server/api/serverless/run_cloud", {
-        method: "POST",
-        handler: () => ({ url }),
+      $fetch.mockImplementation((route, options) => {
+        const data = { url };
+        // oxlint-disable-next-line eslint/id-length
+        options.onResponse?.({ response: { ok: true, _data: data } });
+        return Promise.resolve(data);
       });
-      await infraStore.create_backend("", "", false);
+
+      await infraStore.create_backend("noreply@example.com");
       expect(infraStore.status).toBe(Status.CREATED);
       expect(infraStore.domain_name).toBe(url);
 

package/tests/unit/utils/validate_schema.nuxt.test.js

@@ -2,7 +2,7 @@
 import { describe, expect, test } from "vitest";
 
 // Local imports
-import { validate_schema } from "@ogw_front/utils/validate_schema";
+import { validate_schema } from "@ogw_shared/utils/validate_schema";
 
 // CONSTANTS
 const MIN_0 = 0;

package/app/utils/validate_schema.js

@@ -1,13 +0,0 @@
-import Ajv from "ajv";
-
-function validate_schema(schema, body) {
-  const ajv = new Ajv();
-  const list_keywords = ["methods", "route", "max_retry", "rpc"];
-  for (const keyword of list_keywords) {
-    ajv.addKeyword(keyword);
-  }
-  const valid = ajv.validate(schema, body);
-  return { valid, error: ajv.errorsText() };
-}
-
-export { validate_schema };