Merge pull request #135 from Geode-solutions/feat/ping_route

Feat/ping route

Author: JulienChampagnol

composables/api_fetch.js

@@ -29,41 +29,46 @@ export function api_fetch(
   if (schema.max_retry) {
     request_options.max_retry = schema.max_retry
   }
-  return useFetch(schema.$id, {
-    baseURL: geode_store.base_url,
-    ...request_options,
-    onRequestError({ error }) {
-      geode_store.stop_request()
-      feedback_store.add_error(
-        error.code,
-        schema.$id,
-        error.message,
-        error.stack,
-      )
-      if (request_error_function) {
-        request_error_function(error)
-      }
-    },
-    onResponse({ response }) {
-      if (response.ok) {
-        geode_store.stop_request()
-        if (response_function) {
-          response_function(response)
+  return new Promise((resolve, reject) => {
+    useFetch(schema.$id, {
+      baseURL: geode_store.base_url,
+      ...request_options,
+      async onRequestError({ error }) {
+        await geode_store.stop_request()
+        await feedback_store.add_error(
+          error.code,
+          schema.$id,
+          error.message,
+          error.stack,
+        )
+        if (request_error_function) {
+          await request_error_function(error)
         }
-      }
-    },
-    onResponseError({ response }) {
-      geode_store.stop_request()
-      feedback_store.add_error(
-        response.status,
-        schema.$id,
-        response._data.name,
-        response._data.description,
-      )
-      if (response_error_function) {
-        response_error_function(response)
-      }
-    },
+        reject(error)
+      },
+      async onResponse({ response }) {
+        if (response.ok) {
+          await geode_store.stop_request()
+          if (response_function) {
+            await response_function(response)
+          }
+          resolve(response)
+        }
+      },
+      async onResponseError({ response }) {
+        await geode_store.stop_request()
+        await feedback_store.add_error(
+          response.status,
+          schema.$id,
+          response._data.name,
+          response._data.description,
+        )
+        if (response_error_function) {
+          await response_error_function(response)
+        }
+        reject(response)
+      },
+    })
   })
 }
 

nuxt.config.js

@@ -9,7 +9,10 @@ export default defineNuxtConfig({
     },
   },
 
-  modules: [["@pinia/nuxt", { autoImports: ["defineStore"] }], "@vueuse/nuxt"],
+  modules: [
+    ["@pinia/nuxt", { autoImports: ["defineStore", "storeToRefs"] }],
+    "@vueuse/nuxt",
+  ],
   imports: {
     dirs: ["stores"],
   },

package.json

@@ -7,8 +7,9 @@
     "geode_objects": "node scripts/generate_geode_objects.js && prettier ./assets/geode_objects.js --write"
   },
   "devDependencies": {
-    "@nuxt/test-utils": "^3.13.1",
-    "@vitejs/plugin-vue": "^5.0.5",
+    "@nuxt/test-utils": "^3.14.1",
+    "@pinia/testing": "^0.1.5",
+    "@vitejs/plugin-vue": "^5.1.3",
     "@vitest/coverage-v8": "^1.6.0",
     "@vue/test-utils": "^2.4.6",
     "eslint": "^8.57.0",
@@ -28,6 +29,7 @@
     "vite-plugin-vuetify": "^2.0.3",
     "vitest": "^1.6.0",
     "vitest-environment-nuxt": "^1.0.0",
+    "vuetify": "^3.6.9",
     "wslink": "1.12.4"
   },
   "overrides": {
@@ -38,22 +40,21 @@
   "version": "0.0.0-semantically-released",
   "main": "./nuxt.config.js",
   "dependencies": {
-    "@geode/opengeodeweb-back": "4.3.0",
-    "@geode/opengeodeweb-viewer": "0.1.2",
+    "@geode/opengeodeweb-back": "5.0.0-rc.1",
+    "@geode/opengeodeweb-viewer": "0.2.0",
     "@kitware/vtk.js": "30.3.1",
     "@mdi/font": "^7.4.47",
-    "@pinia/nuxt": "^0.5.1",
-    "@types/node": "^20.14.2",
-    "@vueuse/components": "^10.11.0",
-    "@vueuse/nuxt": "^10.11.0",
-    "ajv": "^8.16.0",
+    "@pinia/nuxt": "^0.5.4",
+    "@types/node": "^22.5.1",
+    "@vueuse/components": "^11.0.3",
+    "@vueuse/nuxt": "^11.0.3",
+    "ajv": "^8.17.1",
     "is-electron": "^2.2.2",
-    "pinia": "^2.1.7",
-    "sass": "^1.77.5",
-    "semver": "^7.6.2",
+    "pinia": "^2.2.2",
+    "sass": "^1.77.8",
+    "semver": "^7.6.3",
     "vue-recaptcha": "^2.0.3",
-    "vue3-carousel": "^0.3.3",
-    "vuetify": "^3.6.9"
+    "vue3-carousel": "^0.3.3"
   },
   "repository": {
     "type": "git",

stores/feedback.js

@@ -4,25 +4,25 @@ export const use_feedback_store = defineStore("feedback", {
     server_error: false,
   }),
   actions: {
-    add_error(code, route, name, description) {
-      this.feedbacks.push({
+    async add_error(code, route, name, description) {
+      await this.feedbacks.push({
         type: "error",
         code,
         route,
         name,
         description,
       })
     },
-    add_success(description) {
-      this.feedbacks.push({
+    async add_success(description) {
+      await this.feedbacks.push({
         type: "success",
         description,
       })
     },
-    delete_feedback(feedback_index) {
-      this.feedbacks.splice(feedback_index, 1)
+    async delete_feedback(feedback_index) {
+      await this.feedbacks.splice(feedback_index, 1)
     },
-    delete_server_error() {
+    async delete_server_error() {
       this.server_error = false
     },
   },

stores/geode.js

@@ -1,16 +1,33 @@
+import back_schemas from "@geode/opengeodeweb-back/schemas.json"
+
 export const use_geode_store = defineStore("geode", {
   state: () => ({
-    PROTOCOL: use_infra_store().is_cloud ? "https" : "http",
-    PORT: use_infra_store().is_cloud ? "443" : "5000",
+    default_local_port: "5000",
     request_counter: 0,
     is_running: false,
   }),
   getters: {
+    protocol() {
+      if (use_infra_store().is_cloud) {
+        return "https"
+      } else {
+        return "http"
+      }
+    },
+    port() {
+      if (use_infra_store().is_cloud) {
+        return "443"
+      } else {
+        return this.default_local_port
+      }
+    },
     base_url() {
       const infra_store = use_infra_store()
-      const api_url = infra_store.api_url
-      var geode_url = `${api_url}`
+      var geode_url = `${this.protocol}://${infra_store.domain_name}:${this.port}`
       if (infra_store.is_cloud) {
+        if (infra_store.ID == "") {
+          throw new Error("ID must not be empty in cloud mode")
+        }
         geode_url += `/${infra_store.ID}/geode`
       }
       return geode_url
@@ -25,16 +42,22 @@ export const use_geode_store = defineStore("geode", {
     },
     async do_ping() {
       const feedback_store = use_feedback_store()
-      const { data } = await useFetch(`${this.base_url}/ping`, {
-        method: "POST",
-      })
-      if (data.value !== null) {
-        this.is_running = true
-        return
-      } else {
-        feedback_store.$patch({ server_error: true })
-        return
-      }
+      await api_fetch(
+        { schema: back_schemas.opengeodeweb_back.ping, params: {} },
+        {
+          request_error_function: async () => {
+            await feedback_store.$patch({ server_error: true })
+            this.is_running = false
+          },
+          response_function: async () => {
+            this.is_running = true
+          },
+          response_error_function: async () => {
+            await feedback_store.$patch({ server_error: true })
+            this.is_running = false
+          },
+        },
+      )
     },
     start_request() {
       this.request_counter++

stores/infra.js

@@ -11,22 +11,26 @@ export const use_infra_store = defineStore("infra", {
     is_cloud() {
       return !isElectron() && !process.env.NODE_ENV === "development"
     },
-    domain_name() {
-      if (this.is_cloud) {
+    domain_name(state) {
+      if (state.is_cloud) {
         return useRuntimeConfig().public.API_URL
       } else {
         return "localhost"
       }
     },
-
-    api_url() {
+    lambda_url(state) {
       const geode_store = use_geode_store()
       const public_runtime_config = useRuntimeConfig().public
-      if (public_runtime_config.NODE_ENV == "test") {
-        return ""
-      }
-      var api_url = `${geode_store.PROTOCOL}://${this.domain_name}:${geode_store.PORT}`
-      return api_url
+      const url =
+        geode_store.protocol +
+        "://" +
+        state.domain_name +
+        ":" +
+        geode_store.port +
+        public_runtime_config.SITE_BRANCH +
+        public_runtime_config.PROJECT +
+        "/createbackend"
+      return url
     },
     is_running() {
       return use_geode_store().is_running && use_viewer_store().is_running
@@ -42,21 +46,14 @@ export const use_infra_store = defineStore("infra", {
         return
       }
       this.is_connexion_launched = true
-      if (
-        this.ID === "" ||
-        this.ID === null ||
-        typeof this.ID === "undefined"
-      ) {
+      if (["", null].includes(this.ID) || typeof this.ID === "undefined") {
         return this.create_backend()
       } else {
-        const { data, error } = await useFetch(`${geode_store.base_url}/`, {
-          method: "POST",
-        })
-        if (data.value !== null) {
-          geode_store.is_running = true
+        try {
+          await geode_store.do_ping()
           return geode_store.ping_task()
-        } else {
-          await this.create_backend()
+        } catch (e) {
+          return this.create_backend()
         }
       }
     },
@@ -66,19 +63,15 @@ export const use_infra_store = defineStore("infra", {
       const feedback_store = use_feedback_store()
 
       if (isElectron()) {
-        await window.electronAPI.run_back(geode_store.PORT)
-        await window.electronAPI.run_viewer(viewer_store.PORT)
-        // geode_store.$patch({ is_running: true })
-        // viewer_store.$patch({ is_running: true })
+        const back_port = await window.electronAPI.run_back(geode_store.port)
+        geode_store.$patch({ default_local_port: back_port })
+        const viewer_port = await window.electronAPI.run_viewer(
+          viewer_store.port,
+        )
+        viewer_store.$patch({ default_local_port: viewer_port })
         return
       } else {
-        const public_runtime_config = useRuntimeConfig().public
-        const url = this.api_url.concat(
-          public_runtime_config.SITE_BRANCH,
-          public_runtime_config.PROJECT,
-          "/createbackend",
-        )
-        const { data, error } = await useFetch(url, {
+        const { data, error } = await useFetch(this.lambda_url, {
           method: "POST",
         })
         if (data.value !== null) {

stores/viewer.js

@@ -5,8 +5,7 @@ import schemas from "@geode/opengeodeweb-viewer/schemas.json"
 
 export const use_viewer_store = defineStore("viewer", {
   state: () => ({
-    PROTOCOL: use_infra_store().is_cloud ? "wss" : "ws",
-    PORT: use_infra_store().is_cloud ? "443" : "1234",
+    default_local_port: "1234",
     client: {},
     config: null,
     is_running: false,
@@ -15,10 +14,27 @@ export const use_viewer_store = defineStore("viewer", {
     request_counter: 0,
   }),
   getters: {
+    protocol() {
+      if (use_infra_store().is_cloud) {
+        return "wss"
+      } else {
+        return "ws"
+      }
+    },
+    port(state) {
+      if (use_infra_store().is_cloud) {
+        return "443"
+      } else {
+        return state.default_local_port
+      }
+    },
     base_url(state) {
       const infra_store = use_infra_store()
-      var viewer_url = `${state.PROTOCOL}://${infra_store.domain_name}:${state.PORT}`
+      let viewer_url = `${state.protocol}://${infra_store.domain_name}:${state.port}`
       if (infra_store.is_cloud) {
+        if (infra_store.ID == "") {
+          throw new Error("ID must not be empty in cloud mode")
+        }
         viewer_url += `/${infra_store.ID}/viewer`
       }
       viewer_url += "/ws"