@geode/opengeodeweb-front 10.4.2-rc.1 → 10.5.0-rc.2

package/app/stores/data.js

@@ -101,20 +101,70 @@ export const useDataStore = defineStore("data", () => {
     await database.data.update(id, changes)
   }
 
-  async function addModelComponents(values) {
+  async function addModelComponents(id, values) {
     if (!values || values.length === 0) {
-      console.debug("[addModelComponents] No mesh components to add")
+      console.debug("[addModelComponents] No components to add")
       return
     }
-    for (const value of values) {
-      value.created_at = new Date().toISOString()
+
+    const { mesh_components, collection_components } = values
+    const allComponents = [
+      ...(mesh_components || []),
+      ...(collection_components || []),
+    ]
+
+    const relations = []
+    for (const component of allComponents) {
+      component.id = id
+      component.created_at = new Date().toISOString()
+
+      if (component.boundaries) {
+        for (const boundary_id of component.boundaries) {
+          relations.push({
+            id,
+            parent: component.geode_id,
+            child: boundary_id,
+            type: "boundary",
+          })
+        }
+        delete component.boundaries
+      }
+      if (component.internals) {
+        for (const internal_id of component.internals) {
+          relations.push({
+            id,
+            parent: component.geode_id,
+            child: internal_id,
+            type: "internal",
+          })
+        }
+        delete component.internals
+      }
+      if (component.items) {
+        for (const item_id of component.items) {
+          relations.push({
+            id,
+            parent: component.geode_id,
+            child: item_id,
+            type: "collection",
+          })
+        }
+        delete component.items
+      }
+    }
+
+    const serializedComponents = structuredClone(allComponents)
+    const serializedRelations = structuredClone(relations)
+
+    await database.model_components.bulkAdd(serializedComponents)
+    if (serializedRelations.length > 0) {
+      await database.model_components_relation.bulkAdd(serializedRelations)
     }
-    const serializedData = structuredClone(values)
-    await database.model_components.bulkAdd(serializedData)
   }
 
   async function deleteModelComponents(id) {
     await database.model_components.where({ id }).delete()
+    await database.model_components_relation.where({ id }).delete()
   }
 
   async function fetchModelComponents(id) {
@@ -124,19 +174,7 @@ export const useDataStore = defineStore("data", () => {
       { id },
       {
         response_function: async (response) => {
-          const allComponents = [
-            ...response.mesh_components.map(
-              ({
-                boundaries: _boundaries,
-                internals: _internals,
-                ...component
-              }) => component,
-            ),
-            ...response.collection_components.map(
-              ({ items: _items, ...component }) => component,
-            ),
-          ].map((component) => Object.assign(component, { id }))
-          await addModelComponents(allComponents)
+          await addModelComponents(id, response)
         },
       },
     )

package/app/stores/geode.js

@@ -92,6 +92,7 @@ export const useGeodeStore = defineStore("geode", {
     },
     request(schema, params, callbacks = {}) {
       console.log("[GEODE] Request:", schema.$id)
+      const start = Date.now()
 
       return api_fetch(
         this,
@@ -99,7 +100,13 @@ export const useGeodeStore = defineStore("geode", {
         {
           ...callbacks,
           response_function: async (response) => {
-            console.log("[GEODE] Request completed:", schema.$id)
+            console.log(
+              "[GEODE] Request completed:",
+              schema.$id,
+              "in",
+              (Date.now() - start) / 1_000,
+              "s",
+            )
             if (callbacks.response_function) {
               await callbacks.response_function(response)
             }

package/app/stores/viewer.js

@@ -170,6 +170,7 @@ export const useViewerStore = defineStore(
       timeout = request_timeout,
     ) {
       console.log("[VIEWER] Request:", schema.$id)
+      const start = Date.now()
 
       // Get current store instance to pass to viewer_call
       const store = useViewerStore()
@@ -180,7 +181,13 @@ export const useViewerStore = defineStore(
         {
           ...callbacks,
           response_function: async (response) => {
-            console.log("[VIEWER] Request completed:", schema.$id)
+            console.log(
+              "[VIEWER] Request completed:",
+              schema.$id,
+              "in",
+              (Date.now() - start) / 1_000,
+              "s",
+            )
             if (callbacks.response_function) {
               await callbacks.response_function(response)
             }

package/internal/database/database.js

@@ -2,6 +2,7 @@ import { Dexie } from "dexie"
 import { ExtendedDatabase } from "./extended_database"
 import { dataTable } from "./tables/data_table"
 import { modelComponentsTable } from "./tables/model_components"
+import { modelComponentsRelationTable } from "./tables/model_components_relation"
 
 class Database extends Dexie {
   constructor() {
@@ -10,6 +11,7 @@ class Database extends Dexie {
     this.version(1).stores({
       [dataTable.name]: dataTable.schema,
       [modelComponentsTable.name]: modelComponentsTable.schema,
+      [modelComponentsRelationTable.name]: modelComponentsRelationTable.schema,
     })
   }
 
@@ -26,6 +28,8 @@ class Database extends Dexie {
 
     currentStores[dataTable.name] = dataTable.schema
     currentStores[modelComponentsTable.name] = modelComponentsTable.schema
+    currentStores[modelComponentsRelationTable.name] =
+      modelComponentsRelationTable.schema
 
     for (const table of tempDb.tables) {
       const keyPath = table.schema.primKey.src
@@ -49,6 +53,8 @@ class Database extends Dexie {
           existingDb.version(1).stores({
             [dataTable.name]: dataTable.schema,
             [modelComponentsTable.name]: modelComponentsTable.schema,
+            [modelComponentsRelationTable.name]:
+              modelComponentsRelationTable.schema,
           })
         } else {
           existingDb.version(version).stores(currentStores)

package/internal/database/extended_database.js

@@ -1,6 +1,7 @@
 import { Dexie } from "dexie"
 import { dataTable } from "./tables/data_table"
 import { modelComponentsTable } from "./tables/model_components"
+import { modelComponentsRelationTable } from "./tables/model_components_relation"
 
 export class ExtendedDatabase extends Dexie {
   constructor(currentVersion, currentStores, newTables) {
@@ -11,6 +12,8 @@ export class ExtendedDatabase extends Dexie {
         this.version(1).stores({
           [dataTable.name]: dataTable.schema,
           [modelComponentsTable.name]: modelComponentsTable.schema,
+          [modelComponentsRelationTable.name]:
+            modelComponentsRelationTable.schema,
         })
       } else {
         this.version(version).stores(currentStores)

package/internal/database/tables/model_components_relation.js

@@ -0,0 +1,4 @@
+export const modelComponentsRelationTable = {
+  name: "model_components_relation",
+  schema: "[id+parent+child+type], id, parent, child, type",
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.4.2-rc.1",
+  "version": "10.5.0-rc.2",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {