qdadm 0.51.5 → 0.51.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qdadm",
-  "version": "0.51.5",
+  "version": "0.51.7",
   "description": "Vue 3 framework for admin dashboards with PrimeVue",
   "author": "quazardous",
   "license": "MIT",

package/src/composables/useEntityItemFormPage.js

@@ -298,7 +298,11 @@ export function useEntityItemFormPage(config = {}) {
           responseData = await manager.update(entityId.value, payload)
         }
       } else {
-        responseData = await manager.create(payload)
+        // Build context with parent chain for multi-storage routing
+        const context = parentConfig.value && parentId.value
+          ? { parentChain: [{ entity: parentConfig.value.entity, id: parentId.value }] }
+          : undefined
+        responseData = await manager.create(payload, context)
       }
 
       toast.add({
@@ -323,18 +327,17 @@ export function useEntityItemFormPage(config = {}) {
         const listRoute = findListRoute()
         router.push(listRoute)
       } else if (!isEdit.value) {
-        // "Create" without close: reset form for new entry, stay on route
-        data.value = deepClone(initialData)
-        originalData.value = null
-        takeSnapshot()
-        errors.value = {}
-        submitted.value = false
-        toast.add({
-          severity: 'info',
-          summary: 'Ready',
-          detail: 'Form reset for new entry',
-          life: 2000
-        })
+        // "Create" without close: navigate to edit route for the created entity
+        const createdId = responseData?.id || responseData?.uuid
+        if (createdId) {
+          // Build edit route: replace 'create' suffix with ':id/edit'
+          const currentRouteName = route.name || ''
+          const editRouteName = currentRouteName.replace(/(-create|-new)$/, '-edit')
+          router.push({
+            name: editRouteName,
+            params: { ...route.params, id: createdId }
+          })
+        }
       }
       // Edit mode without close: just stay on page (data already updated)
 

package/src/composables/useListPage.js

@@ -186,6 +186,34 @@ export function useListPage(config = {}) {
   const parentLoading = computed(() => parentPage?.loading.value || false)
   const parentChain = computed(() => parentPage?.parentChain.value || new Map())
 
+  /**
+   * Build entity context with parentChain array for multi-storage routing
+   * Format: { parentChain: [{ entity: 'grandparent', id: '1' }, { entity: 'parent', id: '42' }] }
+   * Array is ordered from root ancestor to immediate parent
+   */
+  const entityContext = computed(() => {
+    if (!parentConfig.value || !parentId.value) {
+      return null
+    }
+
+    // Build chain from config (traversing from immediate parent to root)
+    const chain = []
+    let currentConfig = parentConfig.value
+
+    while (currentConfig) {
+      const entityId = route.params[currentConfig.param]
+      if (!entityId) break
+
+      chain.unshift({
+        entity: currentConfig.entity,
+        id: entityId
+      })
+      currentConfig = currentConfig.parent
+    }
+
+    return chain.length > 0 ? { parentChain: chain } : null
+  })
+
   // Read config from manager with option overrides
   const entityName = config.entityName ?? manager.label
   const entityNamePlural = config.entityNamePlural ?? manager.labelPlural
@@ -1124,9 +1152,10 @@ export function useListPage(config = {}) {
       }
 
       // Use manager.query() for automatic cache handling
+      // Pass entityContext for multi-storage routing
       const response = manager.query
-        ? await manager.query(params)
-        : await manager.list(params)
+        ? await manager.query(params, { routingContext: entityContext.value })
+        : await manager.list(params, entityContext.value)
 
       // Track if response came from cache
       fromCache.value = response.fromCache || false

package/src/debug/EntitiesCollector.js

@@ -345,7 +345,8 @@ export class EntitiesCollector extends Collector {
         type: s.storage?.constructor?.storageName || s.storage?.constructor?.name || 'Unknown',
         endpoint: s.storage?.endpoint || null,
         hasNormalize: !!(s.storage?._normalize),
-        hasDenormalize: !!(s.storage?._denormalize)
+        hasDenormalize: !!(s.storage?._denormalize),
+        capabilities: s.storage?.capabilities || s.storage?.constructor?.capabilities || {}
       }))
     }
   }
@@ -489,4 +490,34 @@ export class EntitiesCollector extends Collector {
       }
     }
   }
+
+  /**
+   * Test fetch data from a specific storage of an entity
+   * @param {string} entityName - Entity name
+   * @param {string} storageName - Storage property name ('storage' for primary)
+   * @returns {Promise<{success: boolean, count?: number, error?: string, status?: number}>}
+   */
+  async testStorageFetch(entityName, storageName) {
+    if (!this._orchestrator) {
+      return { success: false, error: 'No orchestrator' }
+    }
+    try {
+      const manager = this._orchestrator.get(entityName)
+      const storage = storageName === 'storage' ? manager.storage : manager[storageName]
+      if (!storage) {
+        return { success: false, error: `Storage '${storageName}' not found` }
+      }
+      const result = await storage.list({ page: 1, page_size: 1 })
+      return {
+        success: true,
+        count: result.total ?? result.items?.length ?? 0
+      }
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message,
+        status: e.status
+      }
+    }
+  }
 }

package/src/debug/components/panels/EntitiesPanel.vue

@@ -21,6 +21,8 @@ const expandedEntities = ref(new Set())
 const loadingCache = ref(new Set())
 const testingFetch = ref(new Set())
 const testResults = ref(new Map()) // entityName -> { success, count, error, status }
+const testingStorages = ref(new Set()) // "entityName:storageName"
+const storageTestResults = ref(new Map()) // "entityName:storageName" -> { success, count, error, status }
 
 function toggleExpand(name) {
   if (expandedEntities.value.has(name)) {
@@ -82,6 +84,31 @@ async function testFetch(entityName) {
   }
 }
 
+function isTestingStorage(entityName, storageName) {
+  return testingStorages.value.has(`${entityName}:${storageName}`)
+}
+
+function getStorageTestResult(entityName, storageName) {
+  return storageTestResults.value.get(`${entityName}:${storageName}`)
+}
+
+async function testStorageFetch(entityName, storageName) {
+  const key = `${entityName}:${storageName}`
+  if (testingStorages.value.has(key)) return
+  testingStorages.value.add(key)
+  testingStorages.value = new Set(testingStorages.value)
+  storageTestResults.value.delete(key)
+  storageTestResults.value = new Map(storageTestResults.value)
+  try {
+    const result = await props.collector.testStorageFetch(entityName, storageName)
+    storageTestResults.value.set(key, result)
+    storageTestResults.value = new Map(storageTestResults.value)
+  } finally {
+    testingStorages.value.delete(key)
+    testingStorages.value = new Set(testingStorages.value)
+  }
+}
+
 function getCapabilityIcon(cap) {
   const icons = {
     supportsTotal: 'pi-hashtag',
@@ -164,41 +191,101 @@ function getCapabilityLabel(cap) {
 
       <!-- Expanded details -->
       <div v-else class="entity-details">
-        <div class="entity-row">
-          <span class="entity-key">Storage:</span>
-          <span class="entity-value">{{ entity.storage.type }}</span>
-          <span v-if="entity.storage.endpoint" class="entity-endpoint">{{ entity.storage.endpoint }}</span>
-          <span v-if="entity.storage.hasNormalize || entity.storage.hasDenormalize" class="entity-normalize-badge" title="Has normalize/denormalize">
-            <i class="pi pi-arrows-h" />
-          </span>
-          <span v-if="entity.multiStorage?.enabled" class="entity-multi-badge" title="Multi-storage routing">
-            <i class="pi pi-sitemap" />
-            +{{ entity.multiStorage.storages.length }}
-          </span>
-        </div>
-        <!-- Multi-storage details -->
-        <div v-if="entity.multiStorage?.enabled && entity.multiStorage.storages.length > 0" class="entity-multi-storages">
-          <div v-for="s in entity.multiStorage.storages" :key="s.name" class="entity-multi-storage">
-            <span class="entity-storage-name">{{ s.name }}</span>
-            <span class="entity-storage-type">{{ s.type }}</span>
-            <span v-if="s.endpoint" class="entity-endpoint">{{ s.endpoint }}</span>
-            <span v-if="s.hasNormalize || s.hasDenormalize" class="entity-normalize-badge" title="Has normalize/denormalize">
-              <i class="pi pi-arrows-h" />
+        <!-- Storages section -->
+        <div class="entity-storages-section">
+          <div class="entity-storages-header">
+            <i class="pi pi-database" />
+            <span>Storages</span>
+            <span v-if="entity.multiStorage?.enabled" class="entity-multi-badge" title="Multi-storage routing">
+              <i class="pi pi-sitemap" />
+              {{ 1 + entity.multiStorage.storages.length }}
             </span>
           </div>
-        </div>
-        <div v-if="entity.storage.capabilities && Object.keys(entity.storage.capabilities).length > 0" class="entity-row">
-          <span class="entity-key">Caps:</span>
-          <div class="entity-capabilities">
-            <span
-              v-for="(enabled, cap) in entity.storage.capabilities"
-              :key="cap"
-              class="entity-cap"
-              :class="[cap === 'requiresAuth' && enabled ? 'entity-cap-auth' : (enabled ? 'entity-cap-enabled' : 'entity-cap-disabled')]"
-              :title="getCapabilityLabel(cap) + (enabled ? ' ✓' : ' ✗')"
-            >
-              <i :class="['pi', getCapabilityIcon(cap)]" />
-            </span>
+
+          <!-- Primary storage -->
+          <div class="entity-storage-card">
+            <div class="entity-storage-header">
+              <span class="entity-storage-name">storage</span>
+              <span class="entity-storage-type">{{ entity.storage.type }}</span>
+              <span v-if="entity.storage.hasNormalize || entity.storage.hasDenormalize" class="entity-normalize-badge" title="Has normalize/denormalize">
+                <i class="pi pi-arrows-h" />
+              </span>
+              <button
+                class="entity-storage-fetch-btn"
+                :disabled="isTestingStorage(entity.name, 'storage')"
+                @click.stop="testStorageFetch(entity.name, 'storage')"
+                title="Test fetch on this storage"
+              >
+                <i :class="['pi', isTestingStorage(entity.name, 'storage') ? 'pi-spin pi-spinner' : 'pi-download']" />
+              </button>
+            </div>
+            <div v-if="entity.storage.endpoint" class="entity-storage-endpoint">
+              {{ entity.storage.endpoint }}
+            </div>
+            <div class="entity-storage-row">
+              <div v-if="entity.storage.capabilities && Object.keys(entity.storage.capabilities).length > 0" class="entity-storage-caps">
+                <span
+                  v-for="(enabled, cap) in entity.storage.capabilities"
+                  :key="cap"
+                  class="entity-cap"
+                  :class="[cap === 'requiresAuth' && enabled ? 'entity-cap-auth' : (enabled ? 'entity-cap-enabled' : 'entity-cap-disabled')]"
+                  :title="getCapabilityLabel(cap) + (enabled ? ' ✓' : ' ✗')"
+                >
+                  <i :class="['pi', getCapabilityIcon(cap)]" />
+                </span>
+              </div>
+              <span v-if="getStorageTestResult(entity.name, 'storage')" class="entity-storage-test-result" :class="getStorageTestResult(entity.name, 'storage').success ? 'test-success' : 'test-error'">
+                <template v-if="getStorageTestResult(entity.name, 'storage').success">
+                  <i class="pi pi-check-circle" /> {{ getStorageTestResult(entity.name, 'storage').count }}
+                </template>
+                <template v-else>
+                  <i class="pi pi-times-circle" /> {{ getStorageTestResult(entity.name, 'storage').status || 'ERR' }}
+                </template>
+              </span>
+            </div>
+          </div>
+
+          <!-- Additional storages -->
+          <div v-for="s in entity.multiStorage?.storages || []" :key="s.name" class="entity-storage-card entity-storage-alt">
+            <div class="entity-storage-header">
+              <span class="entity-storage-name">{{ s.name }}</span>
+              <span class="entity-storage-type">{{ s.type }}</span>
+              <span v-if="s.hasNormalize || s.hasDenormalize" class="entity-normalize-badge" title="Has normalize/denormalize">
+                <i class="pi pi-arrows-h" />
+              </span>
+              <button
+                class="entity-storage-fetch-btn"
+                :disabled="isTestingStorage(entity.name, s.name)"
+                @click.stop="testStorageFetch(entity.name, s.name)"
+                title="Test fetch on this storage"
+              >
+                <i :class="['pi', isTestingStorage(entity.name, s.name) ? 'pi-spin pi-spinner' : 'pi-download']" />
+              </button>
+            </div>
+            <div v-if="s.endpoint" class="entity-storage-endpoint">
+              {{ s.endpoint }}
+            </div>
+            <div class="entity-storage-row">
+              <div v-if="s.capabilities && Object.keys(s.capabilities).length > 0" class="entity-storage-caps">
+                <span
+                  v-for="(enabled, cap) in s.capabilities"
+                  :key="cap"
+                  class="entity-cap"
+                  :class="[cap === 'requiresAuth' && enabled ? 'entity-cap-auth' : (enabled ? 'entity-cap-enabled' : 'entity-cap-disabled')]"
+                  :title="getCapabilityLabel(cap) + (enabled ? ' ✓' : ' ✗')"
+                >
+                  <i :class="['pi', getCapabilityIcon(cap)]" />
+                </span>
+              </div>
+              <span v-if="getStorageTestResult(entity.name, s.name)" class="entity-storage-test-result" :class="getStorageTestResult(entity.name, s.name).success ? 'test-success' : 'test-error'">
+                <template v-if="getStorageTestResult(entity.name, s.name).success">
+                  <i class="pi pi-check-circle" /> {{ getStorageTestResult(entity.name, s.name).count }}
+                </template>
+                <template v-else>
+                  <i class="pi pi-times-circle" /> {{ getStorageTestResult(entity.name, s.name).status || 'ERR' }}
+                </template>
+              </span>
+            </div>
           </div>
         </div>
         <div v-if="entity.cache.enabled" class="entity-row">
@@ -231,29 +318,6 @@ function getCapabilityLabel(cap) {
           <span class="entity-key">Cache:</span>
           <span class="entity-value entity-cache-na">Disabled</span>
         </div>
-        <!-- Test Fetch row - always visible for testing auth protection -->
-        <div class="entity-row">
-          <span class="entity-key">Test:</span>
-          <span v-if="getTestResult(entity.name)" class="entity-test-result" :class="getTestResult(entity.name).success ? 'test-success' : 'test-error'">
-            <template v-if="getTestResult(entity.name).success">
-              <i class="pi pi-check-circle" />
-              {{ getTestResult(entity.name).count }} items
-            </template>
-            <template v-else>
-              <i class="pi pi-times-circle" />
-              {{ getTestResult(entity.name).status || 'ERR' }}: {{ getTestResult(entity.name).error }}
-            </template>
-          </span>
-          <span v-else class="entity-value entity-test-na">-</span>
-          <button
-            class="entity-test-btn"
-            :disabled="isTesting(entity.name)"
-            @click.stop="testFetch(entity.name)"
-          >
-            <i :class="['pi', isTesting(entity.name) ? 'pi-spin pi-spinner' : 'pi-download']" />
-            {{ isTesting(entity.name) ? 'Testing...' : 'Fetch' }}
-          </button>
-        </div>
         <div class="entity-row">
           <span class="entity-key">Fields:</span>
           <span class="entity-value">{{ entity.fields.count }} fields</span>
@@ -620,27 +684,97 @@ function getCapabilityLabel(cap) {
   font-size: 10px;
   font-weight: 600;
 }
-.entity-multi-storages {
-  margin-left: 66px;
-  margin-top: 4px;
+/* Storages section */
+.entity-storages-section {
+  margin-bottom: 8px;
+}
+.entity-storages-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  color: #a1a1aa;
+  font-size: 11px;
   margin-bottom: 6px;
-  padding-left: 8px;
+}
+.entity-storages-header .pi {
+  font-size: 10px;
+}
+.entity-storage-card {
+  background: #1f1f23;
+  border-radius: 4px;
+  padding: 6px 8px;
+  margin-bottom: 4px;
   border-left: 2px solid #3b82f6;
 }
-.entity-multi-storage {
+.entity-storage-alt {
+  border-left-color: #8b5cf6;
+}
+.entity-storage-header {
   display: flex;
   align-items: center;
   gap: 6px;
-  padding: 3px 0;
-  font-size: 10px;
 }
 .entity-storage-name {
   color: #60a5fa;
   font-weight: 500;
-  min-width: 80px;
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 11px;
+}
+.entity-storage-alt .entity-storage-name {
+  color: #a78bfa;
 }
 .entity-storage-type {
   color: #a1a1aa;
+  font-size: 10px;
+}
+.entity-storage-endpoint {
+  color: #71717a;
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 10px;
+  padding: 2px 0;
+  margin-top: 2px;
+}
+.entity-storage-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 4px;
+}
+.entity-storage-caps {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+}
+.entity-storage-fetch-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  margin-left: auto;
+  background: #3b82f6;
+  border: none;
+  border-radius: 3px;
+  color: #fff;
+  cursor: pointer;
+  font-size: 10px;
+}
+.entity-storage-fetch-btn:hover {
+  background: #2563eb;
+}
+.entity-storage-fetch-btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.entity-storage-test-result {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  padding: 2px 6px;
+  border-radius: 3px;
+  font-size: 10px;
+  margin-left: auto;
 }
 .entity-capabilities {
   display: flex;

package/src/entity/EntityManager.js

@@ -916,7 +916,7 @@ export class EntityManager {
    * @returns {Promise<{ items: Array, total: number, fromCache: boolean }>}
    */
   async list(params = {}, context) {
-    const { storage } = this.resolveStorage('list', context)
+    const { storage, path } = this.resolveStorage('list', context)
     if (!storage) {
       throw new Error(`[EntityManager:${this.name}] list() not implemented`)
     }
@@ -949,8 +949,22 @@ export class EntityManager {
 
     if (!_internal) this._stats.cacheMisses++
 
-    // 2. Fetch from API (storage normalizes response to { items, total })
-    const response = await storage.list(queryParams)
+    // 2. Fetch from API
+    let response
+    if (path && storage.request) {
+      // Use request() with path for multi-storage routing
+      // Build query params for GET request
+      const apiResponse = await storage.request('GET', path, { params: queryParams })
+      // Normalize response: handle both { data: [...], pagination: {...} } and { items, total }
+      const data = apiResponse.data ?? apiResponse
+      response = {
+        items: Array.isArray(data) ? data : (data.items || data.data || []),
+        total: data.total ?? data.pagination?.total ?? (Array.isArray(data) ? data.length : 0)
+      }
+    } else {
+      // Standard storage.list() (normalizes response to { items, total })
+      response = await storage.list(queryParams)
+    }
     const items = response.items || []
     const total = response.total ?? items.length
 
@@ -998,7 +1012,7 @@ export class EntityManager {
    * @returns {Promise<object>}
    */
   async get(id, context) {
-    const { storage } = this.resolveStorage('get', context)
+    const { storage, path } = this.resolveStorage('get', context)
     this._stats.get++
 
     // Try cache first if valid and complete
@@ -1014,6 +1028,11 @@ export class EntityManager {
     // Fallback to storage
     this._stats.cacheMisses++
     if (storage) {
+      // Use request() with path for multi-storage routing, otherwise use get()
+      if (path && storage.request) {
+        const response = await storage.request('GET', `${path}/${id}`)
+        return response.data ?? response
+      }
       return storage.get(id)
     }
     throw new Error(`[EntityManager:${this.name}] get() not implemented`)
@@ -1069,15 +1088,21 @@ export class EntityManager {
    * @returns {Promise<object>} - The created entity
    */
   async create(data, context) {
-    const { storage } = this.resolveStorage('create', context)
+    const { storage, path } = this.resolveStorage('create', context)
     this._stats.create++
     if (storage) {
       // Invoke presave hooks (can modify data or throw to abort)
       const presaveContext = this._buildPresaveContext(data, true)
       await this._invokeHook('presave', presaveContext)
 
-      // Use potentially modified data from context
-      const result = await storage.create(presaveContext.record)
+      // Use request() with path for multi-storage routing, otherwise use create()
+      let result
+      if (path && storage.request) {
+        const response = await storage.request('POST', path, { data: presaveContext.record })
+        result = response.data ?? response
+      } else {
+        result = await storage.create(presaveContext.record)
+      }
       this.invalidateCache()
 
       // Invoke postsave hooks (for side effects)
@@ -1108,15 +1133,21 @@ export class EntityManager {
    * @returns {Promise<object>}
    */
   async update(id, data, context) {
-    const { storage } = this.resolveStorage('update', context)
+    const { storage, path } = this.resolveStorage('update', context)
     this._stats.update++
     if (storage) {
       // Invoke presave hooks (can modify data or throw to abort)
       const presaveContext = this._buildPresaveContext(data, false, id)
       await this._invokeHook('presave', presaveContext)
 
-      // Use potentially modified data from context
-      const result = await storage.update(id, presaveContext.record)
+      // Use request() with path for multi-storage routing, otherwise use update()
+      let result
+      if (path && storage.request) {
+        const response = await storage.request('PUT', `${path}/${id}`, { data: presaveContext.record })
+        result = response.data ?? response
+      } else {
+        result = await storage.update(id, presaveContext.record)
+      }
       this.invalidateCache()
 
       // Invoke postsave hooks (for side effects)
@@ -1143,17 +1174,25 @@ export class EntityManager {
    *
    * @param {string|number} id
    * @param {object} data
+   * @param {object} [context] - Routing context for multi-storage
    * @returns {Promise<object>}
    */
-  async patch(id, data) {
+  async patch(id, data, context) {
+    const { storage, path } = this.resolveStorage('patch', context)
     this._stats.update++  // patch counts as update
-    if (this.storage) {
+    if (storage) {
       // Invoke presave hooks (can modify data or throw to abort)
       const presaveContext = this._buildPresaveContext(data, false, id)
       await this._invokeHook('presave', presaveContext)
 
-      // Use potentially modified data from context
-      const result = await this.storage.patch(id, presaveContext.record)
+      // Use request() with path for multi-storage routing, otherwise use patch()
+      let result
+      if (path && storage.request) {
+        const response = await storage.request('PATCH', `${path}/${id}`, { data: presaveContext.record })
+        result = response.data ?? response
+      } else {
+        result = await storage.patch(id, presaveContext.record)
+      }
       this.invalidateCache()
 
       // Invoke postsave hooks (for side effects)
@@ -1182,14 +1221,20 @@ export class EntityManager {
    * @returns {Promise<void>}
    */
   async delete(id, context) {
-    const { storage } = this.resolveStorage('delete', context)
+    const { storage, path } = this.resolveStorage('delete', context)
     this._stats.delete++
     if (storage) {
       // Invoke predelete hooks (can throw to abort, e.g., for cascade checks)
       const predeleteContext = this._buildPredeleteContext(id)
       await this._invokeHook('predelete', predeleteContext)
 
-      const result = await storage.delete(id)
+      // Use request() with path for multi-storage routing, otherwise use delete()
+      let result
+      if (path && storage.request) {
+        result = await storage.request('DELETE', `${path}/${id}`)
+      } else {
+        result = await storage.delete(id)
+      }
       this.invalidateCache()
       this._emitSignal('deleted', {
         manager: this.name,
@@ -1638,25 +1683,24 @@ export class EntityManager {
    * @param {object} params - Query params (search, filters, sort_by, sort_order, page, page_size)
    * @param {object} [options] - Query options
    * @param {object} [options.context] - Context info (module, form, field, scope, bypassPermissions, reason)
+   * @param {object} [options.routingContext] - Multi-storage routing context with parentChain
    * @returns {Promise<{ items: Array, total: number, fromCache: boolean }>}
    */
   async query(params = {}, options = {}) {
-    const { context = {} } = options
+    const { context = {}, routingContext = null } = options
 
     // Ensure cache is filled (via list)
     if (!this._cache.valid && this.isCacheEnabled) {
-      await this.list({ page_size: this.effectiveThreshold })
+      await this.list({ page_size: this.effectiveThreshold }, routingContext)
     }
 
     let result
 
     // If overflow or cache disabled, use API for accurate filtered results
     if (this.overflow || !this.isCacheEnabled) {
-      console.log('[cache] API call for entity:', this.name, '(total > threshold)', 'isCacheEnabled:', this.isCacheEnabled, 'overflow:', this.overflow)
-      result = await this.list(params)
+      result = await this.list(params, routingContext)
     } else {
       // Full cache available - filter locally
-      console.log('[cache] Using local cache for entity:', this.name)
       const filtered = this._filterLocally(this._cache.items, params)
       result = { ...filtered, fromCache: true }
     }

package/src/entity/storage/ApiStorage.js

@@ -21,16 +21,6 @@ import { IStorage } from './IStorage.js'
  *   getClient: () => inject('apiClient')
  * })
  *
- * // With parameter mapping (transform filter names for API)
- * const storage = new ApiStorage({
- *   endpoint: '/commands',
- *   client: apiClient,
- *   paramMapping: {
- *     bot_uuid: 'botUuid',  // filters.bot_uuid → ?botUuid=xxx
- *     page_size: 'limit'    // page_size → ?limit=xxx
- *   }
- * })
- *
  * // With data normalization (different API format)
  * const storage = new ApiStorage({
  *   endpoint: '/api/projects/:id/tasks',
@@ -84,8 +74,8 @@ export class ApiStorage extends IStorage {
       // Response format configuration
       responseItemsKey = 'items',
       responseTotalKey = 'total',
-      // Parameter mapping: { clientName: apiName }
-      // Transforms filter and query param names before sending to API
+      // WIP: Parameter mapping for filters { clientName: apiName }
+      // Transforms filter param names before sending to API
       paramMapping = {},
       // Data normalization
       // normalize: (apiData) => internalData - transform API response
@@ -104,6 +94,23 @@ export class ApiStorage extends IStorage {
     this._denormalize = denormalize
   }
 
+  /**
+   * WIP: Apply parameter mapping to transform filter names
+   * @param {object} params - Original params
+   * @returns {object} - Params with mapped names
+   */
+  _applyParamMapping(params) {
+    if (!this.paramMapping || Object.keys(this.paramMapping).length === 0) {
+      return params
+    }
+    const mapped = {}
+    for (const [key, value] of Object.entries(params)) {
+      const mappedKey = this.paramMapping[key] || key
+      mapped[mappedKey] = value
+    }
+    return mapped
+  }
+
   /**
    * Normalize API response data to internal format
    * @param {object|Array} data - API response data
@@ -127,24 +134,6 @@ export class ApiStorage extends IStorage {
     return this._denormalize(data)
   }
 
-  /**
-   * Apply parameter mapping to transform names
-   * @param {object} params - Original params
-   * @returns {object} - Params with mapped names
-   */
-  _applyParamMapping(params) {
-    if (!this.paramMapping || Object.keys(this.paramMapping).length === 0) {
-      return params
-    }
-
-    const mapped = {}
-    for (const [key, value] of Object.entries(params)) {
-      const mappedKey = this.paramMapping[key] || key
-      mapped[mappedKey] = value
-    }
-    return mapped
-  }
-
   get client() {
     if (this._getClient) {
       return this._getClient()
@@ -169,7 +158,7 @@ export class ApiStorage extends IStorage {
   async list(params = {}) {
     const { page = 1, page_size = 20, sort_by, sort_order, filters = {} } = params
 
-    // Apply param mapping to filters
+    // WIP: Apply param mapping to filters
     const mappedFilters = this._applyParamMapping(filters)
 
     const response = await this.client.get(this.endpoint, {

package/src/kernel/Kernel.js

@@ -48,6 +48,7 @@ import { createQdadm } from '../plugin.js'
 import { initModules, getRoutes, setSectionOrder, alterMenuSections, registry } from '../module/moduleRegistry.js'
 import { createModuleLoader } from './ModuleLoader.js'
 import { createKernelContext } from './KernelContext.js'
+import { ToastBridgeModule } from '../toast/ToastBridgeModule.js'
 import { Orchestrator } from '../orchestrator/Orchestrator.js'
 import { createSignalBus } from './SignalBus.js'
 import { createZoneRegistry } from '../zones/ZoneRegistry.js'
@@ -98,6 +99,7 @@ export class Kernel {
    * @param {object} options.eventRouter - EventRouter config { 'source:signal': ['target:signal', ...] }
    * @param {object} options.sse - SSEBridge config { url, reconnectDelay, signalPrefix, autoConnect, events }
    * @param {object} options.debugBar - Debug bar config { module: DebugModule, component: QdadmDebugBar, ...options }
+   * @param {boolean} options.toast - Enable ToastBridgeModule (default: true). Set to false to disable.
    */
   constructor(options) {
     // Auto-inject DebugModule if debugBar.module is provided
@@ -122,6 +124,15 @@ export class Kernel {
         options.debug = true
       }
     }
+
+    // Auto-inject ToastBridgeModule unless toast: false
+    // Handles toast:* signals from useSignalToast() composable
+    if (options.toast !== false) {
+      options.moduleDefs = options.moduleDefs || []
+      // Add at beginning for high priority (loads early)
+      options.moduleDefs.unshift(new ToastBridgeModule())
+    }
+
     this.options = options
     this.vueApp = null
     this.router = null
@@ -569,11 +580,12 @@ export class Kernel {
     }
 
     // Build home route
+    // Note: Must have a name to avoid Vue Router warning when parent (_layout) has a name
     let homeRouteConfig
     if (typeof homeRoute === 'object' && homeRoute.component) {
-      homeRouteConfig = { path: '', ...homeRoute }
+      homeRouteConfig = { path: '', name: homeRoute.name || '_home', ...homeRoute }
     } else {
-      homeRouteConfig = { path: '', redirect: { name: homeRoute || 'home' } }
+      homeRouteConfig = { path: '', name: '_home', redirect: { name: homeRoute || 'home' } }
     }
 
     // Collect all module routes