feat(app_store): adding app-store.js to save all stores and loop all keys and return t…

plugins/autoStoreRegister.js

@@ -0,0 +1,29 @@
+import { useAppStore } from "../stores/app_store"
+
+export const autoStoreRegister = ({ store }) => {
+  if (!store || !store.$id) {
+    console.warn("[AutoRegister] Invalid store object received", store)
+    return
+  }
+
+  if (store.$id === "app") {
+    return
+  }
+
+  const appStore = useAppStore()
+
+  const isAlreadyRegistered = appStore.stores.some(
+    (registeredStore) => registeredStore.$id === store.$id,
+  )
+
+  if (!isAlreadyRegistered) {
+    appStore.registerStore(store)
+    console.log(`[AutoRegister] Store "${store.$id}" registered`)
+  } else {
+    console.log(
+      `[AutoRegister] Store "${store.$id}" already registered, skipping`,
+    )
+  }
+}
+
+export default autoStoreRegister

stores/app_store.js

@@ -0,0 +1,74 @@
+export const useAppStore = defineStore("app", () => {
+  const stores = []
+
+  function registerStore(store) {
+    console.log("[AppStore] Registering store", store.$id)
+    stores.push(store)
+  }
+
+  function save() {
+    const snapshot = {}
+    let savedCount = 0
+
+    for (const store of stores) {
+      if (!store.save) {
+        continue
+      }
+      const storeId = store.$id
+      try {
+        snapshot[storeId] = store.save()
+        savedCount++
+      } catch (error) {
+        console.error(`[AppStore] Error saving store "${storeId}":`, error)
+      }
+    }
+
+    console.log(`[AppStore] Saved ${savedCount} stores`)
+    return snapshot
+  }
+
+  function load(snapshot) {
+    if (!snapshot) {
+      console.warn("[AppStore] load called with invalid snapshot")
+      return
+    }
+
+    let loadedCount = 0
+    const notFoundStores = []
+
+    for (const store of stores) {
+      if (!store.load) {
+        continue
+      }
+
+      const storeId = store.$id
+
+      if (!snapshot[storeId]) {
+        notFoundStores.push(storeId)
+        continue
+      }
+
+      try {
+        store.load(snapshot[storeId])
+        loadedCount++
+      } catch (error) {
+        console.error(`[AppStore] Error loading store "${storeId}":`, error)
+      }
+    }
+
+    if (notFoundStores.length > 0) {
+      console.warn(
+        `[AppStore] Stores not found in snapshot: ${notFoundStores.join(", ")}`,
+      )
+    }
+
+    console.log(`[AppStore] Loaded ${loadedCount} stores`)
+  }
+
+  return {
+    stores,
+    registerStore,
+    save,
+    load,
+  }
+})

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.10.3

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.11.3

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

@@ -0,0 +1,206 @@
+import { beforeEach, describe, expect, expectTypeOf, test, vi } from "vitest"
+import { createTestingPinia } from "@pinia/testing"
+import { useAppStore } from "@/stores/app_store.js"
+import { setActivePinia } from "pinia"
+
+beforeEach(async () => {
+  const pinia = createTestingPinia({
+    stubActions: false,
+    createSpy: vi.fn,
+  })
+  setActivePinia(pinia)
+})
+
+describe("App Store", () => {
+  describe("state", () => {
+    test("initial state", () => {
+      const app_store = useAppStore()
+      expectTypeOf(app_store.stores).toBeArray()
+      expectTypeOf(app_store.save).toBeFunction()
+      expectTypeOf(app_store.load).toBeFunction()
+      expectTypeOf(app_store.registerStore).toBeFunction()
+    })
+  })
+
+  describe("actions", () => {
+    describe("registerStore", () => {
+      test("register single store", () => {
+        const app_store = useAppStore()
+        const mock_store = {
+          $id: "testStore",
+          save: vi.fn().mockImplementation(() => ({ data: "test" })),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store)
+
+        expect(app_store.stores.length).toBe(1)
+        expect(app_store.stores[0]).toStrictEqual(mock_store)
+      })
+
+      test("register multiple stores", () => {
+        const app_store = useAppStore()
+        const mock_store_1 = {
+          $id: "userStore",
+          save: vi.fn().mockImplementation(() => {}),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+        const mock_store_2 = {
+          $id: "cartStore",
+          save: vi.fn().mockImplementation(() => {}),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store_1)
+        app_store.registerStore(mock_store_2)
+
+        expect(app_store.stores.length).toBe(2)
+        expect(app_store.stores[0].$id).toBe("userStore")
+        expect(app_store.stores[1].$id).toBe("cartStore")
+      })
+    })
+
+    describe("save", () => {
+      test("save stores with save method", () => {
+        const app_store = useAppStore()
+        const mock_store_1 = {
+          $id: "userStore",
+          save: vi.fn().mockImplementation(() => ({
+            name: "toto",
+            email: "[email protected]",
+          })),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+        const mock_store_2 = {
+          $id: "cartStore",
+          save: vi.fn().mockImplementation(() => ({ items: [], total: 0 })),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store_1)
+        app_store.registerStore(mock_store_2)
+
+        const snapshot = app_store.save()
+
+        expect(mock_store_1.save).toHaveBeenCalledTimes(1)
+        expect(mock_store_2.save).toHaveBeenCalledTimes(1)
+        expect(snapshot).toEqual({
+          userStore: { name: "toto", email: "[email protected]" },
+          cartStore: { items: [], total: 0 },
+        })
+      })
+
+      test("skip stores without save method", () => {
+        const app_store = useAppStore()
+        const mock_store_1 = {
+          $id: "withSave",
+          save: vi.fn().mockImplementation(() => ({ data: "test" })),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+        const mock_store_2 = {
+          $id: "withoutSave",
+          load: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store_1)
+        app_store.registerStore(mock_store_2)
+
+        const snapshot = app_store.save()
+
+        expect(mock_store_1.save).toHaveBeenCalledTimes(1)
+        expect(snapshot).toEqual({
+          withSave: { data: "test" },
+        })
+        expect(snapshot.withoutSave).toBeUndefined()
+      })
+
+      test("return empty snapshot when no stores registered", () => {
+        const app_store = useAppStore()
+        const snapshot = app_store.save()
+        expect(snapshot).toEqual({})
+      })
+    })
+
+    describe("load", () => {
+      test("load stores with load method", () => {
+        const app_store = useAppStore()
+        const mock_store_1 = {
+          $id: "userStore",
+          save: vi.fn().mockImplementation(() => {}),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+        const mock_store_2 = {
+          $id: "cartStore",
+          save: vi.fn().mockImplementation(() => {}),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store_1)
+        app_store.registerStore(mock_store_2)
+
+        const snapshot = {
+          userStore: { name: "tata", email: "[email protected]" },
+          cartStore: { items: [{ id: 1 }], total: 50 },
+        }
+
+        app_store.load(snapshot)
+
+        expect(mock_store_1.load).toHaveBeenCalledTimes(1)
+        expect(mock_store_1.load).toHaveBeenCalledWith({
+          name: "tata",
+          email: "[email protected]",
+        })
+        expect(mock_store_2.load).toHaveBeenCalledTimes(1)
+        expect(mock_store_2.load).toHaveBeenCalledWith({
+          items: [{ id: 1 }],
+          total: 50,
+        })
+      })
+
+      test("skip stores without load method", () => {
+        const app_store = useAppStore()
+        const mock_store_1 = {
+          $id: "withLoad",
+          save: vi.fn().mockImplementation(() => {}),
+          load: vi.fn().mockImplementation(() => {}),
+        }
+        const mock_store_2 = {
+          $id: "withoutLoad",
+          save: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store_1)
+        app_store.registerStore(mock_store_2)
+
+        const snapshot = {
+          withLoad: { data: "test" },
+          withoutLoad: { data: "ignored" },
+        }
+
+        app_store.load(snapshot)
+
+        expect(mock_store_1.load).toHaveBeenCalledTimes(1)
+        expect(mock_store_2.load).toBeUndefined()
+      })
+
+      test("warn when store not found in snapshot", () => {
+        const app_store = useAppStore()
+        const console_warn_spy = vi
+          .spyOn(console, "warn")
+          .mockImplementation(() => {})
+        const mock_store = {
+          $id: "testStore",
+          load: vi.fn().mockImplementation(() => {}),
+        }
+
+        app_store.registerStore(mock_store)
+        app_store.load({})
+
+        expect(console_warn_spy).toHaveBeenCalledWith(
+          expect.stringContaining("Stores not found in snapshot: testStore"),
+        )
+        console_warn_spy.mockRestore()
+      })
+    })
+  })
+})