fix(Cloud): store ID in infraStore

app/stores/infra.js

@@ -4,13 +4,14 @@
 export const useInfraStore = defineStore("infra", {
   state: () => ({
     app_mode: getAppMode(),
+    ID: "",
     is_captcha_validated: false,
     status: Status.NOT_CREATED,
     microservices: [],
   }),
   getters: {
     domain_name() {
       if (this.app_mode == appMode.CLOUD) {
         return useRuntimeConfig().public.API_URL
       }
       return "localhost"
@@ -29,12 +30,12 @@
       const store_name = store.$id
       console.log("[INFRA] Registering microservice:", store_name)
 
       if (!this.microservices.find((store) => store.$id === store_name)) {
         this.microservices.push(store)
         console.log("[INFRA] Microservice registered:", store_name)
       }
     },
     async create_backend() {
       console.log("[INFRA] Starting create_backend - Mode:", this.app_mode)
       console.log(
         "[INFRA] Registered microservices:",
@@ -43,12 +44,12 @@
 
       if (this.status === Status.CREATED) return
 
       return navigator.locks.request("infra.create_backend", async (lock) => {
         this.status = Status.CREATING
         if (this.status === Status.CREATED) return
         console.log("[INFRA] Lock granted for create_backend")
 
         if (this.app_mode == appMode.DESKTOP) {
           console.log("[INFRA] DESKTOP mode - Launching microservices...")
           const microservices_with_launch = this.microservices.filter(
             (store) => store.launch,
@@ -62,10 +63,10 @@
           microservices_with_launch.forEach((store, index) => {
             store.$patch({ default_local_port: ports[index] })
           })
         } else if (this.app_mode == appMode.CLOUD) {
           console.log("[INFRA] CLOUD mode - Launching lambda...")
           const lambdaStore = useLambdaStore()
-          await lambdaStore.launch()
+          this.ID = await lambdaStore.launch()
           console.log("[INFRA] Lambda launched successfully")
         }
 
@@ -81,15 +82,15 @@
         this.microservices.map((store) => store.$id),
       )
 
       const connection_promises = this.microservices.map((store) => {
         return store.connect().then(() => {
           console.log("[INFRA] Microservice connected:", store.$id)
         })
       })
 
       await Promise.all(connection_promises)
       console.log("[INFRA] All microservices connected")
       return
     },
   },
   share: {

app/stores/lambda.js

@@ -1,28 +1,28 @@
 import Status from "@ogw_front/utils/status.js"
 
 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 url =
         this.protocol +
         "://" +
         domain_name +
         ":" +
         this.port +
         public_runtime_config.SITE_BRANCH +
         public_runtime_config.PROJECT +
         "/createbackend"
       return url
     },
     is_busy() {
@@ -30,8 +30,8 @@
     },
   },
   actions: {
     async launch() {
       console.log("[LAMBDA] Launching lambda backend...")
       const feedbackStore = useFeedbackStore()
 
       const { data, error } = await useFetch(this.base_url, {
@@ -41,20 +41,20 @@
       if (error.value || !data.value) {
         this.status = Status.NOT_CONNECTED
         feedbackStore.server_error = true
-        console.error("[LAMBDA] Failed to launch lambda backend")
+        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
     },
     async connect() {
       console.log("[LAMBDA] Lambda connected")
       this.status = Status.CONNECTED
       return Promise.resolve()
     },
   },
   share: {

tests/integration/microservices/back/requirements.txt

@@ -5,4 +5,3 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==5.*,>=5.14.0

tests/integration/microservices/viewer/requirements.txt

@@ -5,4 +5,3 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.13.1rc1

tests/unit/stores/Infra.nuxt.test.js

@@ -29,276 +29,280 @@
   setActivePinia(pinia)
 })
 
 describe("Infra Store", () => {
   describe("state", () => {
     test("initial state", () => {
       const infra_store = useInfraStore()
       expectTypeOf(infra_store.ID).toBeString()
       expectTypeOf(infra_store.is_captcha_validated).toBeBoolean()
       expectTypeOf(infra_store.status).toBeString()
     })
   })
   describe("getters", () => {
     describe("app_mode", () => {
       test("test type", () => {
         const infra_store = useInfraStore()
         expectTypeOf(infra_store.app_mode).toBeString()
       })
     })
 
     describe("domain_name", () => {
       test("test app_mode BROWSER", () => {
         const infra_store = useInfraStore()
         infra_store.app_mode = appMode.BROWSER
         expect(infra_store.domain_name).toBe("localhost")
       })
       test("test app_mode DESKTOP", () => {
         const infra_store = useInfraStore()
         infra_store.app_mode = appMode.DESKTOP
         expect(infra_store.domain_name).toBe("localhost")
       })
       test("test app_mode CLOUD", () => {
         const infra_store = useInfraStore()
         infra_store.app_mode = appMode.CLOUD
         expect(infra_store.domain_name).toBe("api.geode-solutions.com")
       })
     })
 
     describe("microservices_connected", () => {
       test("test no microservices registered", () => {
         const infra_store = useInfraStore()
         expect(infra_store.microservices_connected).toBe(true)
       })
       test("test geode false & viewer false", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ status: Status.NOT_CONNECTED })
         viewerStore.$patch({ status: Status.NOT_CONNECTED })
         expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode true & viewer false", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ status: Status.CONNECTED })
         viewerStore.$patch({ status: Status.NOT_CONNECTED })
         expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode false & viewer true", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ status: Status.NOT_CONNECTED })
         viewerStore.$patch({ status: Status.CONNECTED })
         expect(infra_store.microservices_connected).toBe(false)
       })
       test("test geode true & viewer true", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ status: Status.CONNECTED })
         viewerStore.$patch({ status: Status.CONNECTED })
         expect(infra_store.microservices_connected).toBe(true)
       })
     })
 
     describe("microservices_busy", () => {
       test("test no microservices registered", () => {
         const infra_store = useInfraStore()
         expect(infra_store.microservices_busy).toBe(false)
       })
       test("test geode false & viewer false", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ request_counter: 0 })
         viewerStore.$patch({ request_counter: 0 })
         expect(infra_store.microservices_busy).toBe(false)
       })
       test("test geode true & viewer false", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ request_counter: 1 })
         viewerStore.$patch({ request_counter: 0 })
         expect(infra_store.microservices_busy).toBe(true)
       })
       test("test geode false & viewer true", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ request_counter: 0 })
         viewerStore.$patch({ request_counter: 1 })
         expect(infra_store.microservices_busy).toBe(true)
       })
       test("test geode true & viewer true", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         geodeStore.$patch({ request_counter: 1 })
         viewerStore.$patch({ request_counter: 1 })
         expect(infra_store.microservices_busy).toBe(true)
       })
     })
   })
 
   describe("actions", () => {
     describe("register_microservice", () => {
       test("register geode microservice", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         expect(infra_store.microservices.length).toBe(1)
         expect(infra_store.microservices[0].$id).toBe("geode")
       })
 
       test("register multiple microservices", () => {
         const infra_store = useInfraStore()
         const geodeStore = useGeodeStore()
         const viewerStore = useViewerStore()
 
         infra_store.register_microservice(geodeStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         infra_store.register_microservice(viewerStore, {
           request: vi.fn(),
           connect: vi.fn(),
           launch: vi.fn(),
         })
 
         expect(infra_store.microservices.length).toBe(2)
       })
     })
 
     describe("create_backend", () => {
       test("test without microservices", async () => {
         const infra_store = useInfraStore()
         infra_store.app_mode = appMode.BROWSER
         await infra_store.create_backend()
         expect(infra_store.status).toBe(Status.CREATED)
       })
-      // test("test with end-point", async () => {
-      //   const infra_store = useInfraStore()
-      //   const geodeStore = useGeodeStore()
-      //   const viewerStore = useViewerStore()
-      //   const feedback_store = useFeedbackStore()
-
-      //   registerEndpoint(infra_store.lambda_url, {
-      //     method: "POST",
-      //     handler: () => ({ ID: "123456" }),
-      //   })
-      //   await infra_store.create_backend()
-      //   expect(infra_store.status).toBe(Status.CREATED)
-      //   expect(geodeStore.status).toBe(Status.NOT_CONNECTED)
-      //   expect(viewerStore.status).toBe(Status.NOT_CONNECTED)
-      //   expect(feedback_store.server_error).toBe(true)
-      // })
+      test("test with end-point", async () => {
+        const infra_store = useInfraStore()
+        const geodeStore = useGeodeStore()
+        const viewerStore = useViewerStore()
+        const feedback_store = useFeedbackStore()
+        const lambdaStore = useLambdaStore()
+
+        infra_store.app_mode = appMode.CLOUD
+        const ID = "123456"
+        registerEndpoint(lambdaStore.base_url, {
+          method: "POST",
+          handler: () => ({ ID }),
+        })
+        await infra_store.create_backend()
+        expect(infra_store.status).toBe(Status.CREATED)
+        expect(infra_store.ID).toBe(ID)
+
+        expect(geodeStore.status).toBe(Status.NOT_CONNECTED)
+        expect(viewerStore.status).toBe(Status.NOT_CONNECTED)
+      })
     })
   })
 })