@geode/opengeodeweb-front 10.11.0 → 10.12.0-rc.1

package/.oxlintrc.json

@@ -122,7 +122,8 @@
         "max-statements": "off",
         "vitest/prefer-to-be-truthy": "off",
         "vitest/prefer-to-be-falsy": "off",
-        "vitest/require-test-timeout": "warn"
+        "vitest/require-test-timeout": "warn",
+        "vitest/prefer-importing-vitest-globals": "off"
       }
     },
     {

package/app/components/Inspector/InspectionButton.vue

@@ -14,8 +14,8 @@ const toggle_loading = useToggle(loading);
 async function get_inspection_results() {
   toggle_loading();
   const params = {
-    geode_object_type: geode_object_type,
-    filename: filename,
+    geode_object_type,
+    filename,
   };
   const geodeStore = useGeodeStore();
 

package/app/components/Launcher.vue

@@ -2,6 +2,7 @@
 import Loading from "@ogw_front/components/Loading";
 import Recaptcha from "@ogw_front/components/Recaptcha";
 import { Status } from "@ogw_front/utils/status";
+import { appMode } from "@ogw_front/utils/local/app_mode";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
 const { logo } = defineProps({
@@ -12,22 +13,16 @@ const { logo } = defineProps({
 });
 
 const infraStore = useInfraStore();
-
-watch(
-  () => infraStore.is_captcha_validated,
-  (value, oldValue) => {
-    if (value && !oldValue && import.meta.client) {
-      infraStore.create_backend();
-    }
-  },
-);
+if (infraStore.app_mode !== appMode.CLOUD) {
+  infraStore.create_backend();
+}
 </script>
 
 <template>
   <v-container class="justify">
     <v-row align-content="center" align="center">
       <v-col
-        v-if="!infraStore.is_captcha_validated"
+        v-if="!infraStore.status == Status.NOT_CREATED"
         class="align"
         cols="12"
         align-self="center"

package/app/components/Recaptcha.vue

@@ -1,9 +1,6 @@
 <script setup>
-import { appMode } from "@ogw_front/utils/local/app_mode";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
-const RESPONSE_STATUS_OK = 200;
-
 const { button_label, button_color, color } = defineProps({
   button_label: {
     type: String,
@@ -20,7 +17,7 @@ const { button_label, button_color, color } = defineProps({
     required: false,
   },
 });
-const infraStore = useInfraStore();
+
 const name = ref("");
 const email = ref("");
 const launch = ref(false);
@@ -40,26 +37,9 @@ const emailRules = [
   },
 ];
 
-onMounted(() => {
-  if (
-    import.meta.client &&
-    (process.env.NODE_ENV !== "production" || infraStore.app_mode !== appMode.CLOUD)
-  ) {
-    infraStore.$patch({ is_captcha_validated: true });
-  }
-});
-async function submit_recaptcha() {
-  const response = await $fetch.raw(`/.netlify/functions/recaptcha`, {
-    method: "POST",
-    body: {
-      name: name.value,
-      email: email.value,
-      launch: launch.value,
-    },
-  });
-  infraStore.$patch({
-    is_captcha_validated: response.status === RESPONSE_STATUS_OK,
-  });
+function submit() {
+  const infraStore = useInfraStore();
+  return infraStore.create_backend(name.value, email.value, launch.value);
 }
 </script>
 
@@ -89,7 +69,7 @@ async function submit_recaptcha() {
   </VRow>
   <VRow align="center" justify="center">
     <VCol cols="4" class="d-flex justify-center align-center">
-      <VBtn :text="button_label" :color="color || button_color" @click="submit_recaptcha" />
+      <VBtn :text="button_label" :color="color || button_color" @click="submit" />
     </VCol>
   </VRow>
 </template>

package/app/components/Viewer/Options/TextureItem.vue

@@ -27,7 +27,7 @@ onMounted(() => {
 function getTextureCoordinates() {
   geodeStore.request(
     back_schemas.opengeodeweb_back.texture_coordinates,
-    { id: id },
+    { id },
     {
       response_function: (response) => {
         texture_coordinates.value = response.texture_coordinates;

package/app/stores/cloud.js

@@ -0,0 +1,63 @@
+import { Status } from "@ogw_front/utils/status";
+import { useAppStore } from "./app";
+import { useFeedbackStore } from "./feedback";
+import { useInfraStore } from "./infra";
+
+export const useCloudStore = defineStore("cloud", {
+  state: () => ({
+    status: Status.NOT_CONNECTED,
+  }),
+  actions: {
+    launch(name, email, launch) {
+      this.status = Status.CONNECTING;
+      console.log("[CLOUD] Launching cloud backend...");
+      const schema = {
+        $id: "/api/app/run_cloud",
+        methods: ["POST"],
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          email: { type: "string" },
+          launch: { type: "boolean" },
+        },
+        required: ["name", "email", "launch"],
+        additionalProperties: true,
+      };
+      const params = {
+        name,
+        email,
+        launch,
+      };
+      console.log("[CLOUD] params", params);
+      const appStore = useAppStore();
+      const feedbackStore = useFeedbackStore();
+      return appStore.request(schema, params, {
+        request_error_function: () => {
+          feedbackStore.$patch({ server_error: true });
+          this.status = Status.NOT_CONNECTED;
+        },
+        response_function: (response) => {
+          feedbackStore.$patch({ server_error: false });
+          console.log(`[CLOUD] Cloud launched on ${response.url}`);
+          this.status = Status.CONNECTED;
+          const infraStore = useInfraStore();
+          infraStore.$patch({
+            domain_name: response.url,
+          });
+        },
+        response_error_function: () => {
+          feedbackStore.$patch({ server_error: true });
+          this.status = Status.NOT_CONNECTED;
+        },
+      });
+    },
+    connect() {
+      console.log("[CLOUD] Cloud connected");
+      this.status = Status.CONNECTED;
+      return Promise.resolve();
+    },
+  },
+  share: {
+    omit: ["status"],
+  },
+});

package/app/stores/geode.js

@@ -33,10 +33,7 @@ export const useGeodeStore = defineStore("geode", {
       const infraStore = useInfraStore();
       let geode_url = `${this.protocol}://${infraStore.domain_name}:${this.port}`;
       if (infraStore.app_mode === appMode.CLOUD) {
-        if (infraStore.ID === "") {
-          throw new Error("ID must not be empty in cloud mode");
-        }
-        geode_url += `/${infraStore.ID}/geode`;
+        geode_url += `/geode`;
       }
       return geode_url;
     },

package/app/stores/infra.js

@@ -2,23 +2,16 @@ import { Status } from "@ogw_front/utils/status";
 import { appMode } from "@ogw_front/utils/local/app_mode";
 import { registerRunningExtensions } from "@ogw_front/utils/extension";
 import { useAppStore } from "@ogw_front/stores/app";
-import { useLambdaStore } from "@ogw_front/stores/lambda";
+import { useCloudStore } from "@ogw_front/stores/cloud";
 
 export const useInfraStore = defineStore("infra", {
   state: () => ({
     app_mode: useRuntimeConfig().public.MODE,
-    ID: "",
-    is_captcha_validated: false,
     status: Status.NOT_CREATED,
     microservices: [],
+    domain_name: "localhost",
   }),
   getters: {
-    domain_name() {
-      if (this.app_mode === appMode.CLOUD) {
-        return useRuntimeConfig().public.API_URL;
-      }
-      return "localhost";
-    },
     microservices_connected() {
       console.log("microservices", this.microservices);
       return this.microservices.every((store) => store.status === Status.CONNECTED);
@@ -37,7 +30,7 @@ export const useInfraStore = defineStore("infra", {
         console.log("[INFRA] Microservice registered:", store_name);
       }
     },
-    create_backend() {
+    create_backend(name, email, launch) {
       console.log("[INFRA] Starting create_backend - Mode:", this.app_mode);
       console.log(
         "[INFRA] Registered microservices:",
@@ -47,18 +40,15 @@ export const useInfraStore = defineStore("infra", {
         return;
       }
       return navigator.locks.request("infra.create_backend", async () => {
-        this.status = Status.CREATING;
         if (this.status === Status.CREATED) {
           return;
         }
+        this.status = Status.CREATING;
         console.log("[INFRA] Lock granted for create_backend");
         if (this.app_mode === appMode.CLOUD) {
-          console.log("[INFRA] CLOUD mode - Launching lambda...");
-          const lambdaStore = useLambdaStore();
-          this.ID = await lambdaStore.launch();
-          console.log("[INFRA] Lambda launched successfully");
+          const cloudStore = useCloudStore();
+          await cloudStore.launch(name, email, launch);
         } else {
-          console.log(`[INFRA] ${this.app_mode} mode - Launching microservices...`);
           const appStore = useAppStore();
           await appStore.createProjectFolder();
           if (this.app_mode === appMode.DESKTOP) {

package/app/stores/viewer.js

@@ -49,10 +49,7 @@ export const useViewerStore = defineStore(
     const base_url = computed(() => {
       let viewer_url = `${protocol.value}://${infraStore.domain_name}:${port.value}`;
       if (infraStore.app_mode === appMode.CLOUD) {
-        if (infraStore.ID === "") {
-          throw new Error("ID must not be empty in cloud mode");
-        }
-        viewer_url += `/${infraStore.ID}/viewer`;
+        viewer_url += `/viewer`;
       }
       viewer_url += "/ws";
       return viewer_url;

package/internal/utils/upload_file.js

@@ -16,7 +16,7 @@ async function upload_file(
 
   const request_options = {
     method: "PUT",
-    body: body,
+    body,
   };
   microservice.start_request();
   return await $fetch(route, {

package/nuxt.config.js

@@ -1,22 +1,19 @@
 // Node imports
-import path, { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import path from "node:path";
 
 // Local imports
 import package_json from "./package.json";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const __dirname = import.meta.dirname;
 
 export default defineNuxtConfig({
   runtimeConfig: {
     public: {
-      API_URL: "api.geode-solutions.com",
       COMMAND_BACK: "opengeodeweb-back",
       COMMAND_VIEWER: "opengeodeweb-viewer",
       NUXT_ROOT_PATH: __dirname,
       MODE: process.env.MODE || "CLOUD",
       PROJECT: package_json.name,
-      SITE_BRANCH: process.env.NODE_ENV === "production" ? process.env.SITE_BRANCH : "",
     },
   },
 
@@ -28,6 +25,7 @@ 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"),
   },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.11.0",
+  "version": "10.12.0-rc.1",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -34,8 +34,9 @@
     "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",
     "@pinia/nuxt": "0.11.3",
@@ -48,6 +49,8 @@
     "conf": "15.1.0",
     "dexie": "4.2.1",
     "get-port-please": "3.2.0",
+    "google-auth-library": "10.6.1",
+    "googleapis": "171.4.0",
     "js-file-download": "0.4.12",
     "jszip": "3.10.1",
     "node-stream-zip": "1.15.0",
@@ -70,17 +73,9 @@
     "@pinia/testing": "1.0.3",
     "@vitejs/plugin-vue": "6.0.4",
     "@vue/test-utils": "2.4.6",
-    "eslint": "9.26.0",
-    "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-nuxt": "4.0.0",
-    "eslint-plugin-prettier": "5.4.0",
-    "eslint-plugin-prettier-vue": "5.0.0",
-    "eslint-plugin-vue": "10.1.0",
-    "eslint-plugin-vuetify": "2.5.2",
     "happy-dom": "20.0.11",
     "msw": "2.11.1",
     "playwright-core": "1.52.0",
-    "prettier": "3.3.3",
     "resize-observer-polyfill": "1.5.1",
     "unplugin-auto-import": "20.0.0",
     "vite": "7.3.1",

package/server/api/app/run_cloud.js

@@ -0,0 +1,46 @@
+// Node imports
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3";
+import { GoogleAuth } from "google-auth-library";
+import { ServicesClient } from "@google-cloud/run";
+
+// Local imports
+import { artifactImages, checkRecaptchaParams, requestConfig } from "@ogw_server/utils/cloud";
+
+export default defineEventHandler(async (event) => {
+  try {
+    const { name, email, launch } = await readBody(event);
+    if (!checkRecaptchaParams(name, email, launch)) {
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ message: "INTERNAL_ERROR" }),
+      };
+    }
+    const credentials = JSON.parse(process.env.GOOGLE_CLOUD_KEY);
+    const location = "europe-west9";
+    const projectId = process.env.GOOGLE_CLOUD_PROJECT;
+    const parent = `projects/${projectId}/locations/${location}`;
+    const auth = new GoogleAuth({
+      credentials,
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
+    const authClient = await auth.getClient();
+    const [routerImage, backImage, viewerImage] = await artifactImages(parent, authClient);
+    const request = requestConfig(parent, routerImage, backImage, viewerImage);
+    const runClient = new ServicesClient({ authClient });
+    const [operation] = await runClient.createService(request);
+    const [response] = await operation.promise();
+    console.log("Service URL created:", response.uri);
+    return {
+      statusCode: 200,
+      url: response.uri.replace(/^https?:\/\//i, ""),
+    };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    });
+  }
+});

package/server/utils/cloud.js

@@ -0,0 +1,96 @@
+// Node imports
+
+// Third party imports
+import { google } from "googleapis";
+
+// Local imports
+
+function checkRecaptchaParams(name, email, launch) {
+  console.log("check_recaptcha_params", { name, email, launch });
+  return name === "" && email === "" && launch === false;
+}
+
+async function artifactImage(registry, parent, repo) {
+  const branch = process.env.BRANCH;
+  const [_, projectId] = parent.split("/");
+  const repository = `${parent}/repositories/ghcr/packages/geode-solutions%2F`;
+  const artifactRegistry = `europe-west9-docker.pkg.dev/${projectId}/ghcr/geode-solutions`;
+  const response = await registry.projects.locations.repositories.packages.tags.get({
+    name: `${repository}${repo}/tags/${branch}`,
+  });
+  const digest = response.data.version.split("/").pop();
+  const image = `${artifactRegistry}/${repo}@${digest}`;
+  console.log("Found image for", repo, image);
+  return image;
+}
+
+function artifactImages(parent, authClient) {
+  const projectName = process.env.PROJECT;
+  const registry = google.artifactregistry({
+    version: "v1",
+    auth: authClient,
+  });
+  return Promise.all([
+    artifactImage(registry, parent, "opengeodeweb-router"),
+    artifactImage(registry, parent, `${projectName}-back`),
+    artifactImage(registry, parent, `${projectName}-viewer`),
+  ]);
+}
+
+// oxlint-disable-next-line max-lines-per-function
+function requestConfig(parent, routerImage, backImage, viewerImage) {
+  const resources = {
+    limits: {
+      cpu: "1000m",
+      memory: "512Mi",
+    },
+  };
+  const volumeMounts = {
+    name: "data",
+    mountPath: "/data",
+  };
+  return {
+    parent,
+    service: {
+      ingress: "INGRESS_TRAFFIC_ALL",
+      invokerIamDisabled: true,
+      scaling: {
+        scalingMode: "MANUAL",
+        manualInstanceCount: 1,
+      },
+      template: {
+        volumes: [
+          {
+            name: "data",
+            emptyDir: {
+              medium: "MEMORY",
+            },
+          },
+        ],
+        containers: [
+          {
+            image: routerImage,
+            ports: [
+              {
+                containerPort: 80,
+              },
+            ],
+            resources,
+          },
+          {
+            image: backImage,
+            resources,
+            volumeMounts: [volumeMounts],
+          },
+          {
+            image: viewerImage,
+            resources,
+            volumeMounts: [volumeMounts],
+          },
+        ],
+      },
+    },
+  };
+}
+
+export { checkRecaptchaParams, artifactImages, requestConfig };

package/tests/unit/components/FileSelector.nuxt.test.js

@@ -85,7 +85,7 @@ describe(FileSelector, () => {
         },
         props: {
           multiple: false,
-          files: files,
+          files,
           auto_upload: true,
         },
       });
@@ -107,7 +107,7 @@ describe(FileSelector, () => {
         },
         props: {
           multiple: false,
-          files: files,
+          files,
           auto_upload: false,
         },
       });

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

@@ -86,7 +86,6 @@ const geodeStoreMock = {
 };
 const infraStoreMock = {
   app_mode: appMode.BROWSER,
-  ID: "1234",
 };
 const viewerStoreMock = {
   ws_connect: vi.fn().mockResolvedValue(),

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

@@ -0,0 +1,89 @@
+// Third party imports
+import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
+import { registerEndpoint } from "@nuxt/test-utils/runtime";
+
+// Local imports
+import { Status } from "@ogw_front/utils/status";
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useCloudStore } from "@ogw_front/stores/cloud";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
+
+// CONSTANTS
+const PROJECT = "project";
+const STATUS_500 = 500;
+
+beforeEach(() => {
+  setupActivePinia();
+});
+
+function setupConfig() {
+  const config = useRuntimeConfig();
+  config.public.PROJECT = PROJECT;
+}
+
+describe("Cloud Store", () => {
+  describe("state", () => {
+    test("initial state", () => {
+      const cloudStore = useCloudStore();
+      expectTypeOf(cloudStore.status).toBeString();
+      expect(cloudStore.status).toBe(Status.NOT_CONNECTED);
+    });
+  });
+
+  describe("actions", () => {
+    describe("launch", () => {
+      const postFakeCall = vi.fn();
+
+      test("successful launch", async () => {
+        setupConfig();
+        const cloudStore = useCloudStore();
+        const feedbackStore = useFeedbackStore();
+
+        registerEndpoint("/api/app/run_cloud", {
+          method: "POST",
+          handler: postFakeCall,
+        });
+
+        postFakeCall.mockImplementation(() => ({
+          url: "http://test.com",
+        }));
+
+        await cloudStore.launch("", "", false);
+
+        expect(cloudStore.status).toBe(Status.CONNECTED);
+        expect(feedbackStore.server_error).toBe(false);
+      });
+
+      test("failed launch - error response", async () => {
+        setupConfig();
+        const cloudStore = useCloudStore();
+        const feedbackStore = useFeedbackStore();
+
+        registerEndpoint("/api/app/run_cloud", {
+          method: "POST",
+          handler: postFakeCall,
+        });
+
+        postFakeCall.mockImplementation(() => {
+          throw createError({
+            status: STATUS_500,
+            statusMessage: "Internal Server Error",
+          });
+        });
+
+        await expect(cloudStore.launch("", "", false)).rejects.toThrow("500 Internal Server Error");
+
+        expect(cloudStore.status).toBe(Status.NOT_CONNECTED);
+        expect(feedbackStore.server_error).toBe(true);
+      });
+    });
+
+    describe("connect", () => {
+      test("successful connect", async () => {
+        const cloudStore = useCloudStore();
+        await cloudStore.connect();
+        expect(cloudStore.status).toBe(Status.CONNECTED);
+      });
+    });
+  });
+});

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

@@ -14,7 +14,6 @@ import { useInfraStore } from "@ogw_front/stores/infra";
 const PORT_443 = "443";
 const PORT_12 = "12";
 const PORT_5000 = "5000";
-const CLOUD_ID = "123456";
 const STATUS_500 = 500;
 const EXPECTED_ONE_REQUEST = 1;
 const EXPECTED_NO_REQUEST = 0;
@@ -88,18 +87,8 @@ describe("geode store", () => {
       const infraStore = useInfraStore();
       const geodeStore = useGeodeStore();
       infraStore.app_mode = appMode.CLOUD;
-      infraStore.ID = CLOUD_ID;
       infraStore.domain_name = "example.com";
-      expect(geodeStore.base_url).toBe(`https://example.com:${PORT_443}/${CLOUD_ID}/geode`);
-    });
-
-    test("app_mode CLOUD, ID empty", () => {
-      const infraStore = useInfraStore();
-      const geodeStore = useGeodeStore();
-      infraStore.app_mode = appMode.CLOUD;
-      infraStore.ID = "";
-      infraStore.domain_name = "example.com";
-      expect(() => geodeStore.base_url).toThrow("ID must not be empty in cloud mode");
+      expect(geodeStore.base_url).toBe(`https://example.com:${PORT_443}/geode`);
     });
   });
 

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

@@ -6,9 +6,9 @@ import { registerEndpoint } from "@nuxt/test-utils/runtime";
 import { Status } from "@ogw_front/utils/status";
 import { appMode } from "@ogw_front/utils/local/app_mode";
 import { setupActivePinia } from "@ogw_tests/utils";
+import { useCloudStore } from "@ogw_front/stores/cloud";
 import { useGeodeStore } from "@ogw_front/stores/geode";
 import { useInfraStore } from "@ogw_front/stores/infra";
-import { useLambdaStore } from "@ogw_front/stores/lambda";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Mock navigator.locks API
@@ -31,8 +31,7 @@ describe("Infra Store", () => {
   describe("state", () => {
     test("initial state", () => {
       const infraStore = useInfraStore();
-      expectTypeOf(infraStore.ID).toBeString();
-      expectTypeOf(infraStore.is_captcha_validated).toBeBoolean();
+      expectTypeOf(infraStore.domain_name).toBeString();
       expectTypeOf(infraStore.status).toBeString();
     });
   });
@@ -58,7 +57,7 @@ describe("Infra Store", () => {
       test("test app_mode CLOUD", () => {
         const infraStore = useInfraStore();
         infraStore.app_mode = appMode.CLOUD;
-        expect(infraStore.domain_name).toBe("api.geode-solutions.com");
+        expect(infraStore.domain_name).toBe("localhost");
       });
     });
 
@@ -273,28 +272,27 @@ describe("Infra Store", () => {
         expect(infraStore.microservices.length).toBe(2);
       });
     });
+  });
 
-    describe("create_backend", () => {
-      // Test without microservices
-      test("test with end-point", async () => {
-        const infraStore = useInfraStore();
-        const geodeStore = useGeodeStore();
-        const viewerStore = useViewerStore();
-        const lambdaStore = useLambdaStore();
-
-        infraStore.app_mode = appMode.CLOUD;
-        const ID = "123456";
-        registerEndpoint(lambdaStore.base_url, {
-          method: "POST",
-          handler: () => ({ ID }),
-        });
-        await infraStore.create_backend();
-        expect(infraStore.status).toBe(Status.CREATED);
-        expect(infraStore.ID).toBe(ID);
-
-        expect(geodeStore.status).toBe(Status.NOT_CONNECTED);
-        expect(viewerStore.status).toBe(Status.NOT_CONNECTED);
+  describe("create_backend", () => {
+    // Test without microservices
+    test("test with end-point", async () => {
+      const infraStore = useInfraStore();
+      const geodeStore = useGeodeStore();
+      const viewerStore = useViewerStore();
+
+      infraStore.app_mode = appMode.CLOUD;
+      const url = "test.com";
+      registerEndpoint("/api/app/run_cloud", {
+        method: "POST",
+        handler: () => ({ url }),
       });
+      await infraStore.create_backend("", "", false);
+      expect(infraStore.status).toBe(Status.CREATED);
+      expect(infraStore.domain_name).toBe(url);
+
+      expect(geodeStore.status).toBe(Status.NOT_CONNECTED);
+      expect(viewerStore.status).toBe(Status.NOT_CONNECTED);
     });
   });
 });

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

@@ -111,18 +111,8 @@ describe("Viewer Store", () => {
         const infraStore = useInfraStore();
         const viewerStore = useViewerStore();
         infraStore.app_mode = appMode.CLOUD;
-        infraStore.ID = "123456";
         infraStore.domain_name = "example.com";
-        expect(viewerStore.base_url).toBe("wss://example.com:443/123456/viewer/ws");
-      });
-
-      test("test app_mode CLOUD, ID empty", () => {
-        const infraStore = useInfraStore();
-        const viewerStore = useViewerStore();
-        infraStore.app_mode = appMode.CLOUD;
-        infraStore.ID = "";
-        infraStore.domain_name = "example.com";
-        expect(() => viewerStore.base_url).toThrowError("ID must not be empty in cloud mode");
+        expect(viewerStore.base_url).toBe("wss://example.com:443/viewer/ws");
       });
     });
     describe("is_busy", () => {

package/tests/vitest.config.js

@@ -1,9 +1,8 @@
 import { defineConfig } from "vitest/config";
 import { defineVitestProject } from "@nuxt/test-utils/config";
-import { fileURLToPath } from "node:url";
 import path from "node:path";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __dirname = import.meta.dirname;
 
 const RETRIES = 3;
 const DEFAULT_RETRY = 0;
@@ -22,14 +21,13 @@ export default defineConfig({
     },
   },
   test: {
-    globals: false,
     setupFiles: [path.resolve(__dirname, "./setup_indexeddb.js")],
     projects: [
       await defineVitestProject({
         test: {
           name: "unit",
-          globals: false,
           include: ["tests/unit/**/*.test.js"],
+          globals: true,
           environment: "nuxt",
           testTimeout: TIMEOUTS.unit,
           setupFiles: [path.resolve(__dirname, "./setup_indexeddb.js")],
@@ -44,8 +42,8 @@ export default defineConfig({
       await defineVitestProject({
         test: {
           name: "integration",
-          globals: false,
           include: ["tests/integration/**/*.test.js"],
+          globals: true,
           environment: "nuxt",
           fileParallelism: false,
           testTimeout: TIMEOUTS.integration,

package/.eslintrc.cjs

@@ -1,15 +0,0 @@
-// oxlint-disable-next-line import/no-commonjs
-module.exports = {
-  root: true,
-  env: {
-    node: true,
-    browser: true,
-    es2021: true,
-  },
-  extends: [
-    "eslint:recommended",
-    "plugin:vue/recommended",
-    "plugin:vuetify/recommended",
-    "plugin:nuxt/recommended",
-  ],
-};

package/app/stores/lambda.js

@@ -1,57 +0,0 @@
-import { Status } from "@ogw_front/utils/status";
-import { useFeedbackStore } from "@ogw_front/stores/feedback";
-
-export const useLambdaStore = defineStore("lambda", {
-  state: () => ({
-    status: Status.NOT_CONNECTED,
-  }),
-  getters: {
-    protocol() {
-      return "https";
-    },
-    port() {
-      return "443";
-    },
-    base_url() {
-      const public_runtime_config = useRuntimeConfig().public;
-      const domain_name = public_runtime_config.API_URL;
-      const projectPath = `/${public_runtime_config.PROJECT}`;
-      const url = `${this.protocol}://${domain_name}:${this.port}${public_runtime_config.SITE_BRANCH}${projectPath}/createbackend`;
-      return url;
-    },
-    is_busy() {
-      return false;
-    },
-  },
-  actions: {
-    async launch() {
-      console.log("[LAMBDA] Launching lambda backend...");
-      const feedbackStore = useFeedbackStore();
-
-      const { data, error } = await useFetch(this.base_url, {
-        method: "POST",
-      });
-
-      if (error.value || !data.value) {
-        this.status = Status.NOT_CONNECTED;
-        feedbackStore.server_error = true;
-        console.error("[LAMBDA] Failed to launch lambda backend", error.value);
-        throw new Error("Failed to launch lambda backend");
-      }
-
-      this.status = Status.CONNECTED;
-      const id = data.value.ID;
-
-      console.log("[LAMBDA] Lambda launched, ID:", id);
-      return id;
-    },
-    connect() {
-      console.log("[LAMBDA] Lambda connected");
-      this.status = Status.CONNECTED;
-      return Promise.resolve();
-    },
-  },
-  share: {
-    omit: ["status"],
-  },
-});

package/app/utils/recaptcha.js

@@ -1,24 +0,0 @@
-function check_recaptcha_params(name, email, launch) {
-  console.log("check_recaptcha_params", { name, email, launch });
-  if (name !== "") {
-    return {
-      statusCode: 500,
-      body: JSON.stringify({ message: "INTERNAL_ERROR" }),
-    };
-  }
-  if (email !== "") {
-    return {
-      statusCode: 500,
-      body: JSON.stringify({ message: "INTERNAL_ERROR" }),
-    };
-  }
-  if (launch !== false) {
-    return {
-      statusCode: 500,
-      body: JSON.stringify({ message: "INTERNAL_ERROR" }),
-    };
-  }
-  return { statusCode: 200, body: JSON.stringify({ message: "OK" }) };
-}
-
-export { check_recaptcha_params };

package/eslint.config.js

@@ -1,28 +0,0 @@
-import nuxt from "eslint-plugin-nuxt";
-import vue from "eslint-plugin-vue";
-import vuetify from "eslint-plugin-vuetify";
-
-// oxlint-disable-next-line import/no-anonymous-default-export
-export default [
-  {
-    files: ["**/*.{js,ts,vue}"],
-    languageOptions: {
-      ecmaVersion: 2021,
-      sourceType: "module",
-      globals: {
-        window: "readonly",
-        document: "readonly",
-      },
-    },
-    plugins: {
-      vue,
-      vuetify,
-      nuxt,
-    },
-    rules: {
-      ...vue.configs.recommended.rules,
-      ...vuetify.configs.recommended.rules,
-      ...nuxt.configs.recommended.rules,
-    },
-  },
-];

package/tests/unit/components/Launcher.nuxt.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-
-import Launcher from "@ogw_front/components/Launcher";
-import ResizeObserver from "resize-observer-polyfill";
-import { flushPromises } from "@vue/test-utils";
-import { mountSuspended } from "@nuxt/test-utils/runtime";
-
-import { setupActivePinia, vuetify } from "@ogw_tests/utils";
-import { useInfraStore } from "@ogw_front/stores/infra";
-
-// Mock navigator.locks API
-const mockLockRequest = vi.fn().mockImplementation(async (name, task) => await task({ name }));
-
-vi.stubGlobal("navigator", {
-  ...navigator,
-  locks: {
-    request: mockLockRequest,
-  },
-});
-
-globalThis.ResizeObserver = ResizeObserver;
-
-describe(Launcher, () => {
-  test(`Mount`, async () => {
-    const pinia = setupActivePinia();
-    const infraStore = useInfraStore();
-    const wrapper = await mountSuspended(Launcher, {
-      global: {
-        plugins: [vuetify, pinia],
-      },
-    });
-    expect(wrapper.exists()).toBe(true);
-    await infraStore.$patch({ is_captcha_validated: true });
-    await flushPromises();
-    expect(infraStore.create_backend).toHaveBeenCalled();
-  });
-});

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

@@ -1,130 +0,0 @@
-// Third party imports
-import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest";
-import { registerEndpoint } from "@nuxt/test-utils/runtime";
-
-// Local imports
-import { Status } from "@ogw_front/utils/status";
-import { setupActivePinia } from "@ogw_tests/utils";
-import { useFeedbackStore } from "@ogw_front/stores/feedback";
-import { useLambdaStore } from "@ogw_front/stores/lambda";
-
-// CONSTANTS
-const PORT_443 = "443";
-const API_URL = "api.example.com";
-const SITE_BRANCH = "/test";
-const PROJECT = "project";
-const TEST_ID = "test-id-123456";
-const STATUS_500 = 500;
-
-beforeEach(() => {
-  setupActivePinia();
-});
-
-function setupConfig() {
-  const config = useRuntimeConfig();
-  config.public.API_URL = API_URL;
-  config.public.SITE_BRANCH = SITE_BRANCH;
-  config.public.PROJECT = PROJECT;
-}
-
-describe("Lambda Store", () => {
-  describe("state", () => {
-    test("initial state", () => {
-      const lambdaStore = useLambdaStore();
-      expectTypeOf(lambdaStore.status).toBeString();
-      expect(lambdaStore.status).toBe(Status.NOT_CONNECTED);
-    });
-  });
-
-  describe("getters", () => {
-    describe("protocol", () => {
-      test("test protocol is always https", () => {
-        const lambdaStore = useLambdaStore();
-        expect(lambdaStore.protocol).toBe("https");
-      });
-    });
-
-    describe("port", () => {
-      test("test port is always 443", () => {
-        const lambdaStore = useLambdaStore();
-        expect(lambdaStore.port).toBe(PORT_443);
-      });
-    });
-
-    describe("base_url", () => {
-      test("test base_url construction", () => {
-        setupConfig();
-        const lambdaStore = useLambdaStore();
-        expect(lambdaStore.base_url).toBe(
-          `https://${API_URL}:${PORT_443}${SITE_BRANCH}/${PROJECT}/createbackend`,
-        );
-      });
-    });
-
-    describe("is_busy", () => {
-      test("test is_busy is always false", () => {
-        const lambdaStore = useLambdaStore();
-        expect(lambdaStore.is_busy).toBe(false);
-      });
-    });
-  });
-
-  describe("actions", () => {
-    describe("launch", () => {
-      const postFakeCall = vi.fn();
-
-      test("successful launch", async () => {
-        setupConfig();
-        const lambdaStore = useLambdaStore();
-        const feedbackStore = useFeedbackStore();
-
-        lambdaStore.base_url = "test-base-url";
-        registerEndpoint(lambdaStore.base_url, {
-          method: "POST",
-          handler: postFakeCall,
-        });
-
-        postFakeCall.mockImplementation(() => ({
-          ID: TEST_ID,
-        }));
-
-        const id = await lambdaStore.launch();
-
-        expect(lambdaStore.status).toBe(Status.CONNECTED);
-        expect(id).toBe(TEST_ID);
-        expect(feedbackStore.server_error).toBe(false);
-      });
-
-      test("failed launch - error response", async () => {
-        setupConfig();
-        const lambdaStore = useLambdaStore();
-        const feedbackStore = useFeedbackStore();
-
-        registerEndpoint(lambdaStore.base_url, {
-          method: "POST",
-          handler: postFakeCall,
-        });
-
-        postFakeCall.mockImplementation(() => {
-          throw createError({
-            status: STATUS_500,
-            statusMessage: "Internal Server Error",
-          });
-        });
-
-        await expect(lambdaStore.launch()).rejects.toThrow("Failed to launch lambda backend");
-
-        expect(lambdaStore.status).toBe(Status.NOT_CONNECTED);
-        expect(feedbackStore.server_error).toBe(true);
-      });
-    });
-
-    describe("connect", () => {
-      test("successful connect", async () => {
-        const lambdaStore = useLambdaStore();
-        await lambdaStore.connect();
-        expect(lambdaStore.status).toBe(Status.CONNECTED);
-      });
-    });
-  });
-});

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

@@ -1,40 +0,0 @@
-// Third party imports
-import { describe, expect, test } from "vitest";
-
-// Local imports
-import { check_recaptcha_params } from "@ogw_front/utils/recaptcha";
-
-describe("recaptcha", () => {
-  const default_name = "";
-  const default_email = "";
-  const default_launch = false;
-  const internal_error = 500;
-  const success = 200;
-
-  describe("wrong params", () => {
-    test("name", () => {
-      const name = "test";
-      const result = check_recaptcha_params(name, default_email, default_launch);
-      expect(result.statusCode).toBe(internal_error);
-    });
-
-    test("email", () => {
-      const email = "test";
-      const result = check_recaptcha_params(default_name, email, default_launch);
-      expect(result.statusCode).toBe(internal_error);
-    });
-
-    test("launch", () => {
-      const launch = true;
-      const result = check_recaptcha_params(default_name, default_email, launch);
-      expect(result.statusCode).toBe(internal_error);
-    });
-  });
-
-  describe("right params", () => {
-    test("name", () => {
-      const result = check_recaptcha_params(default_name, default_email, default_launch);
-      expect(result.statusCode).toBe(success);
-    });
-  });
-});