@geode/opengeodeweb-front 7.1.2-rc.3 → 8.0.0-rc.1

package/components/Launcher.vue

@@ -19,15 +19,15 @@
 
 <script setup>
   const viewer_store = use_viewer_store()
-  const cloud_store = use_cloud_store()
+  const infra_store = use_infra_store()
   const { is_captcha_validated, is_connexion_launched, is_running } =
-    storeToRefs(cloud_store)
+    storeToRefs(infra_store)
 
   const site_key = useRuntimeConfig().public.RECAPTCHA_SITE_KEY
 
   watch(is_captcha_validated, async (value) => {
     if (value === true && process.client) {
-      await cloud_store.create_connexion()
+      await infra_store.create_connexion()
       await viewer_store.ws_connect()
     }
   })

package/components/PackagesVersions.vue

@@ -19,8 +19,8 @@
 </template>
 
 <script setup>
-  const cloud_store = use_cloud_store()
-  const { is_running } = storeToRefs(cloud_store)
+  const infra_store = use_infra_store()
+  const { is_running } = storeToRefs(infra_store)
 
   const props = defineProps({
     schema: { type: Object, required: true },

package/components/Recaptcha.vue

@@ -13,8 +13,8 @@
 
 <script setup>
   import { VueRecaptcha } from "vue-recaptcha"
-  const cloud_store = use_cloud_store()
-  const { is_captcha_validated } = storeToRefs(cloud_store)
+  const infra_store = use_infra_store()
+  const { is_captcha_validated } = storeToRefs(infra_store)
 
   const props = defineProps({
     site_key: { type: String, required: true },
@@ -25,7 +25,7 @@
     if (process.client) {
       const config = useRuntimeConfig()
       if (config.public.NODE_ENV !== "production") {
-        cloud_store.$patch({ is_captcha_validated: true })
+        infra_store.$patch({ is_captcha_validated: true })
       }
     }
   })
@@ -35,7 +35,7 @@
       const response = await $fetch.raw(
         `/.netlify/functions/recaptcha?token=${token}`,
       )
-      cloud_store.$patch({ is_captcha_validated: response.status == 200 })
+      infra_store.$patch({ is_captcha_validated: response.status == 200 })
       recaptcha.reset()
     } catch (error) {
       console.error(error)

package/components/Wrapper.vue

@@ -15,8 +15,8 @@
 </template>
 
 <script setup>
-  const cloud_store = use_cloud_store()
-  const { is_running } = storeToRefs(cloud_store)
+  const infra_store = use_infra_store()
+  const { is_running } = storeToRefs(infra_store)
 
   const props = defineProps({
     versions_schema: { type: Object, required: true },

package/composables/run_function_when_infra_running.js

@@ -0,0 +1,15 @@
+export function run_function_when_infra_running(function_to_run) {
+  const infra_store = use_infra_store()
+  const { is_running } = storeToRefs(infra_store)
+  if (is_running.value) {
+    function_to_run()
+  } else {
+    watch(is_running, (value) => {
+      if (value) {
+        function_to_run()
+      }
+    })
+  }
+}
+
+export default run_function_when_infra_running

package/nuxt.config.js

@@ -1,10 +1,7 @@
 export default defineNuxtConfig({
   runtimeConfig: {
     public: {
-      VIEWER_PROTOCOL: process.env.NODE_ENV === "production" ? "wss" : "ws",
-      GEODE_PROTOCOL: process.env.NODE_ENV === "production" ? "https" : "http",
-      VIEWER_PORT: process.env.NODE_ENV === "production" ? "443" : "1234",
-      GEODE_PORT: process.env.NODE_ENV === "production" ? "443" : "5000",
+      API_URL: "api.geode-solutions.com",
       SITE_BRANCH:
         process.env.NODE_ENV === "production" ? process.env.SITE_BRANCH : "",
       PROJECT: process.env.NODE_ENV === "production" ? process.env.PROJECT : "",

package/package.json

@@ -7,26 +7,26 @@
     "geode_objects": "node scripts/generate_geode_objects.js && prettier ./assets/geode_objects.js --write"
   },
   "devDependencies": {
-    "@nuxt/test-utils": "^3.12.0",
-    "@vitejs/plugin-vue": "^5.0.4",
-    "@vitest/coverage-v8": "^1.4.0",
-    "@vue/test-utils": "^2.4.5",
+    "@nuxt/test-utils": "^3.13.1",
+    "@vitejs/plugin-vue": "^5.0.5",
+    "@vitest/coverage-v8": "^1.6.0",
+    "@vue/test-utils": "^2.4.6",
     "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-nuxt": "^4.0.0",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-prettier-vue": "^5.0.0",
-    "eslint-plugin-vue": "^9.24.0",
-    "eslint-plugin-vuetify": "^2.2.0",
-    "happy-dom": "^13.10.1",
-    "jsdom": "^24.0.0",
-    "nuxt": "^3.11.2",
-    "playwright-core": "^1.43.0",
-    "prettier": "3.2.5",
+    "eslint-plugin-vue": "^9.26.0",
+    "eslint-plugin-vuetify": "^2.4.0",
+    "happy-dom": "^14.12.0",
+    "jsdom": "^24.1.0",
+    "nuxt": "^3.12.1",
+    "playwright-core": "^1.44.1",
+    "prettier": "3.3.2",
     "resize-observer-polyfill": "^1.5.1",
-    "vite": "^5.2.8",
+    "vite": "^5.2.13",
     "vite-plugin-vuetify": "^2.0.3",
-    "vitest": "^1.4.0",
+    "vitest": "^1.6.0",
     "vitest-environment-nuxt": "^1.0.0",
     "wslink": "^1.12.4"
   },
@@ -35,24 +35,25 @@
   },
   "description": "OpenSource Vue/Vuetify framework for web applications",
   "type": "module",
-  "version": "7.1.2-rc.3",
+  "version": "8.0.0-rc.1",
   "main": "./nuxt.config.js",
   "dependencies": {
     "@geode/opengeodeweb-back": "4.2.1",
     "@geode/opengeodeweb-viewer": "0.1.2",
-    "@kitware/vtk.js": "^30.3.1",
+    "@kitware/vtk.js": "^30.6.2",
     "@mdi/font": "^7.4.47",
     "@pinia/nuxt": "^0.5.1",
-    "@types/node": "^20.12.4",
-    "@vueuse/components": "^10.9.0",
-    "@vueuse/nuxt": "^10.9.0",
-    "ajv": "^8.12.0",
+    "@types/node": "^20.14.2",
+    "@vueuse/components": "^10.11.0",
+    "@vueuse/nuxt": "^10.11.0",
+    "ajv": "^8.16.0",
+    "is-electron": "^2.2.2",
     "pinia": "^2.1.7",
-    "sass": "^1.74.1",
-    "semver": "^7.6.0",
+    "sass": "^1.77.5",
+    "semver": "^7.6.2",
     "vue-recaptcha": "^2.0.3",
     "vue3-carousel": "^0.3.3",
-    "vuetify": "^3.6.8"
+    "vuetify": "^3.6.9"
   },
   "repository": {
     "type": "git",

package/stores/geode.js

@@ -1,20 +1,21 @@
 export const use_geode_store = defineStore("geode", {
   state: () => ({
+    PROTOCOL: use_infra_store().is_cloud ? "https" : "http",
+    PORT: use_infra_store().is_cloud ? "443" : "5000",
     request_counter: 0,
     is_running: false,
   }),
   getters: {
-    base_url: () => {
-      const cloud_store = use_cloud_store()
-      const api_url = cloud_store.api_url
+    base_url() {
+      const infra_store = use_infra_store()
+      const api_url = infra_store.api_url
       var geode_url = `${api_url}`
-      const public_runtime_config = useRuntimeConfig().public
-      if (public_runtime_config.NODE_ENV == "production") {
-        geode_url += `/${cloud_store.ID}/geode`
+      if (infra_store.is_cloud) {
+        geode_url += `/${infra_store.ID}/geode`
       }
       return geode_url
     },
-    is_busy: (state) => {
+    is_busy(state) {
       return state.request_counter > 0
     },
   },

package/stores/infra.js

@@ -0,0 +1,95 @@
+import { useStorage } from "@vueuse/core"
+import isElectron from "is-electron"
+
+export const use_infra_store = defineStore("infra", {
+  state: () => ({
+    ID: useStorage("ID", ""),
+    is_captcha_validated: false,
+    is_connexion_launched: false,
+  }),
+  getters: {
+    is_cloud() {
+      return !isElectron() && !process.env.NODE_ENV === "development"
+    },
+    domain_name() {
+      if (this.is_cloud) {
+        return useRuntimeConfig().public.API_URL
+      } else {
+        return "localhost"
+      }
+    },
+
+    api_url() {
+      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
+    },
+    is_running() {
+      return use_geode_store().is_running && use_viewer_store().is_running
+    },
+    is_busy() {
+      return use_geode_store().is_busy || use_viewer_store().is_busy
+    },
+  },
+  actions: {
+    async create_connexion() {
+      const geode_store = use_geode_store()
+      if (this.is_connexion_launched) {
+        return
+      }
+      this.is_connexion_launched = true
+      if (
+        this.ID === "" ||
+        this.ID === null ||
+        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
+          return geode_store.ping_task()
+        } else {
+          await this.create_backend()
+        }
+      }
+    },
+    async create_backend() {
+      const geode_store = use_geode_store()
+      const viewer_store = use_viewer_store()
+      const errors_store = use_errors_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 })
+        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, {
+          method: "POST",
+        })
+        if (data.value !== null) {
+          this.ID = data.value.ID
+          localStorage.setItem("ID", data.value.ID)
+          geode_store.$patch({ is_running: true })
+          return geode_store.ping_task()
+        } else {
+          errors_store.server_error = true
+        }
+      }
+    },
+  },
+})

package/stores/viewer.js

@@ -5,6 +5,8 @@ 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",
     client: {},
     config: null,
     is_running: false,
@@ -13,17 +15,16 @@ export const use_viewer_store = defineStore("viewer", {
     request_counter: 0,
   }),
   getters: {
-    base_url: () => {
-      const cloud_store = use_cloud_store()
-      const public_runtime_config = useRuntimeConfig().public
-      var viewer_url = `${public_runtime_config.VIEWER_PROTOCOL}://${public_runtime_config.API_URL}:${public_runtime_config.VIEWER_PORT}`
-      if (process.env.NODE_ENV == "production") {
-        viewer_url += `/${cloud_store.ID}/viewer`
+    base_url(state) {
+      const infra_store = use_infra_store()
+      var viewer_url = `${state.PROTOCOL}://${infra_store.domain_name}:${state.PORT}`
+      if (infra_store.is_cloud) {
+        viewer_url += `/${infra_store.ID}/viewer`
       }
       viewer_url += "/ws"
       return viewer_url
     },
-    is_busy: (state) => {
+    is_busy(state) {
       return state.request_counter > 0
     },
   },

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

@@ -15,22 +15,22 @@
 //   directives,
 // })
 
-// const cloud_store = use_cloud_store()
+// const infra_store = use_infra_store()
 
 // global.ResizeObserver = require("resize-observer-polyfill")
 
 // describe("Launcher.vue", async () => {
 //   test(`Mount`, async () => {
-//     const spy_cloud_store = vi.spyOn(cloud_store, "create_connexion")
+//     const spy_infra_store = vi.spyOn(infra_store, "create_connexion")
 //     const wrapper = await mountSuspended(Launcher, {
 //       global: {
 //         plugins: [vuetify],
 //       },
 //     })
 //     expect(wrapper.exists()).toBe(true)
-//     await cloud_store.$patch({ is_captcha_validated: true })
+//     await infra_store.$patch({ is_captcha_validated: true })
 //     flushPromises()
-//     expect(spy_cloud_store).toHaveBeenCalled()
+//     expect(spy_infra_store).toHaveBeenCalled()
 //   })
 // })
 describe("Fake", async () => {

package/test/composables/{runFunctionIfCloudRunning.nuxt.test.js → run_function_when_infra_running.nuxt.test.js}

@@ -1,6 +1,6 @@
 import { describe, expect, test, beforeEach, vi } from "vitest"
 
-describe("api_fetch.js", () => {
+describe("run_function_when_infra_running", () => {
   const geode_store = use_geode_store()
   const viewer_store = use_viewer_store()
 
@@ -16,13 +16,13 @@ describe("api_fetch.js", () => {
     await geode_store.$patch({ is_running: true })
     await viewer_store.$patch({ is_running: true })
 
-    await runFunctionIfCloudRunning(dumb_obj.dumb_method)
+    await run_function_when_infra_running(dumb_obj.dumb_method)
     expect(spy).toHaveBeenCalled()
   })
 
   test("is_running false", async () => {
     const spy = vi.spyOn(dumb_obj, "dumb_method")
-    runFunctionIfCloudRunning(dumb_obj.dumb_method)
+    run_function_when_infra_running(dumb_obj.dumb_method)
     await geode_store.$patch({ is_running: true })
     await viewer_store.$patch({ is_running: true })
     expect(spy).toHaveBeenCalled()

package/test/stores/Cloud.nuxt.test.js

@@ -2,7 +2,7 @@ import { describe, test, expect, beforeEach } from "vitest"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
 import { flushPromises } from "@vue/test-utils"
 
-const cloud_store = use_cloud_store()
+const infra_store = use_infra_store()
 const geode_store = use_geode_store()
 const viewer_store = use_viewer_store()
 
@@ -14,16 +14,16 @@ describe("Cloud Store", () => {
 
   describe("getters", () => {
     test("is_running", async () => {
-      expect(cloud_store.is_running).toBe(false)
+      expect(infra_store.is_running).toBe(false)
       await geode_store.$patch({ is_running: true })
       await viewer_store.$patch({ is_running: true })
-      expect(cloud_store.is_running).toBe(true)
+      expect(infra_store.is_running).toBe(true)
     })
     test("is_busy", async () => {
-      expect(cloud_store.is_busy).toBe(false)
+      expect(infra_store.is_busy).toBe(false)
       await geode_store.start_request()
       await viewer_store.start_request()
-      expect(cloud_store.is_busy).toBe(true)
+      expect(infra_store.is_busy).toBe(true)
     })
   })
 
@@ -31,7 +31,7 @@ describe("Cloud Store", () => {
     describe("create_backend", async () => {
       test("test without end-point", async () => {
         expect(geode_store.is_running).toBe(false)
-        await cloud_store.create_backend()
+        await infra_store.create_backend()
         expect(geode_store.is_running).toBe(false)
       })
       test("test with end-point", async () => {
@@ -40,7 +40,7 @@ describe("Cloud Store", () => {
           method: "POST",
           handler: () => ({ ID: "123456" }),
         })
-        await cloud_store.create_backend()
+        await infra_store.create_backend()
         await flushPromises()
       })
     })

package/test/stores/Geode.test.js

@@ -1,6 +1,6 @@
 import { setActivePinia, createPinia } from "pinia"
 import { use_geode_store } from "@/stores/geode"
-import { use_cloud_store } from "@/stores/cloud"
+import { use_infra_store } from "@/stores/infra"
 import { describe, test, expect, beforeEach } from "vitest"
 import { registerEndpoint } from "@nuxt/test-utils/runtime"
 
@@ -12,9 +12,7 @@ describe("Geode Store", () => {
   globalThis.useRuntimeConfig = () => {
     return {
       public: {
-        GEODE_PROTOCOL: "http",
         API_URL: "localhost",
-        GEODE_PORT: "5000",
         NODE_ENV: "production",
       },
     }
@@ -22,8 +20,8 @@ describe("Geode Store", () => {
 
   test("base_url", () => {
     const geode_store = use_geode_store()
-    const cloud_store = use_cloud_store()
-    cloud_store.$patch({ ID: "123456" })
+    const infra_store = use_infra_store()
+    infra_store.$patch({ ID: "123456" })
     geode_store.start_request()
     expect(geode_store.request_counter).toBe(1)
   })

package/test/stores/Viewer.nuxt.test.js

@@ -8,8 +8,8 @@ describe("Viewer Store", () => {
   describe("getters", () => {
     test("base_url", () => {
       const viewer_store = use_geode_store()
-      const cloud_store = use_cloud_store()
-      cloud_store.$patch({ ID: "123456" })
+      const infra_store = use_infra_store()
+      infra_store.$patch({ ID: "123456" })
       viewer_store.start_request()
       expect(viewer_store.request_counter).toBe(1)
     })

package/composables/runFunctionIfCloudRunning.js

@@ -1,13 +0,0 @@
-export default async function (function_to_run) {
-  const cloud_store = use_cloud_store()
-  const { is_running } = storeToRefs(cloud_store)
-  if (is_running.value) {
-    function_to_run()
-  } else {
-    watch(is_running, (value) => {
-      if (value) {
-        function_to_run()
-      }
-    })
-  }
-}

package/stores/cloud.js

@@ -1,73 +0,0 @@
-import { useStorage } from "@vueuse/core"
-
-export const use_cloud_store = defineStore("cloud", {
-  state: () => ({
-    ID: useStorage("ID", ""),
-    is_captcha_validated: false,
-    is_connexion_launched: false,
-  }),
-  getters: {
-    api_url: () => {
-      const public_runtime_config = useRuntimeConfig().public
-      if (public_runtime_config.NODE_ENV == "test") {
-        return ""
-      }
-      var api_url = `${public_runtime_config.GEODE_PROTOCOL}://${public_runtime_config.API_URL}:${public_runtime_config.GEODE_PORT}`
-      return api_url
-    },
-    is_running: () => {
-      return use_geode_store().is_running && use_viewer_store().is_running
-    },
-    is_busy: () => {
-      return use_geode_store().is_busy || use_viewer_store().is_busy
-    },
-  },
-  actions: {
-    async create_connexion() {
-      const geode_store = use_geode_store()
-      if (this.is_connexion_launched) {
-        return
-      }
-      this.is_connexion_launched = true
-      if (
-        this.ID === "" ||
-        this.ID === null ||
-        typeof this.ID === "undefined"
-      ) {
-        return this.create_backend()
-      } else {
-        const { data } = await useFetch(`${geode_store.base_url}/ping`, {
-          method: "POST",
-        })
-        if (data.value !== null) {
-          geode_store.is_running = true
-          return geode_store.ping_task()
-        } else {
-          return this.create_backend()
-        }
-      }
-    },
-    async create_backend() {
-      const geode_store = use_geode_store()
-      const errors_store = use_errors_store()
-      const public_runtime_config = useRuntimeConfig().public
-      const url = this.api_url.concat(
-        public_runtime_config.SITE_BRANCH,
-        public_runtime_config.PROJECT,
-        "/createbackend",
-      )
-      const { data } = await useFetch(url, {
-        method: "POST",
-      })
-
-      if (data.value !== null) {
-        this.ID = data.value.ID
-        localStorage.setItem("ID", data.value.ID)
-        geode_store.$patch({ is_running: true })
-        return geode_store.ping_task()
-      } else {
-        errors_store.server_error = true
-      }
-    },
-  },
-})