diff --git a/internal/cmd/ui/src/components/Drawer.vue b/internal/cmd/ui/src/components/Drawer.vue
index 4af443c59d5d59ed9d9fa92d4b34fd2122fdf509..65642c50ce7df36cb8e083ac7347285118e33689 100644
--- a/internal/cmd/ui/src/components/Drawer.vue
+++ b/internal/cmd/ui/src/components/Drawer.vue
@@ -39,18 +39,10 @@
         :prepend-icon="mdiDatabase"
       >
       </v-list-item>
-      <template v-for="type in typeMetadata" :key="type">
+      <template v-for="type in items" :key="type">
         <v-list-item
-          :to="{
-            name: 'browse',
-            params: {
-              dbModelName,
-              path: ['-', type.name],
-            },
-          }"
+          :to="`/${dbModelName}/${type.path}`"
           :prepend-icon="type.icon"
-          v-if="dbmodel[type.name]"
-          :key="[dbModelName, dbmodel[type.name]].join('_')"
         >
           <v-list-item-title class="d-flex"
             >{{ type.name }}
@@ -110,7 +102,7 @@ import { storeToRefs } from "pinia";
 import { computed, ref } from "vue";
 import logo from "../assets/logo-icon.svg?raw";
 import { totalScore } from "../audit";
-import { typeMetadata } from "../dbobjects";
+import { find, typeMetadata } from "../dbobjects";
 import { useData } from "../services/data";
 import { useStateStore } from "../stores/state";
 import AnnotationsBadge from "./AnnotationsBadge.vue";
@@ -124,6 +116,13 @@ const searchBtn = ref(null);
 const score = computed(() => {
   return totalScore(dbmodel.value);
 });
+
+// Only items with a path and with components for this path
+const items = computed(() => {
+  return Object.values(typeMetadata).filter(
+    (t) => t.path && find(dbmodel.value, t.path),
+  );
+});
 </script>
 
 <style>
diff --git a/internal/cmd/ui/src/dbobjects.js b/internal/cmd/ui/src/dbobjects.js
index 4cc1b527596652c41308e7926f0a38127605ced3..ebcdcff705af0ec9541458da1c3cd5d286fc6613 100644
--- a/internal/cmd/ui/src/dbobjects.js
+++ b/internal/cmd/ui/src/dbobjects.js
@@ -30,86 +30,121 @@ export const typeMetadata = {
   Model: {
     name: "Database",
     icon: mdiDatabase,
+    path: "",
   },
   Role: {
     name: "Roles",
     icon: mdiAccount,
     attribute: "Roles",
+    path: "-/Roles",
   },
   Schema: {
     name: "Schemas",
     icon: mdiFolderOutline,
+    path: "-/Schemas",
   },
   Sequence: {
     name: "Sequences",
     icon: mdiNumeric,
     attribute: "Sequences",
+    path: "-/Sequences",
   },
   Table: {
     name: "Tables",
     icon: mdiTable,
     attribute: "Tables",
     color: "#A6CBFF",
+    path: "-/Tables",
   },
   TemporaryTable: { icon: mdiTableClock, attribute: "Tables" },
-  View: { name: "Views", icon: mdiEyeOutline, attribute: "Views" },
+  View: {
+    name: "Views",
+    icon: mdiEyeOutline,
+    attribute: "Views",
+    path: "-/Views",
+  },
   MaterializedView: {
     name: "MaterializedViews",
     icon: mdiEye,
     attribute: "MaterializedViews",
+    path: "-/MaterializedViews",
   },
   Index: {
     name: "Indexes",
     icon: mdiSortAlphabeticalAscending,
     attribute: "Indexes",
     color: "#424242",
+    path: "-/Tables/-/Indexes",
+  },
+  Type: { name: "Types", icon: mdiShape, attribute: "Types", path: "-/Types" },
+  Variable: {
+    name: "Variables",
+    icon: mdiVariable,
+    attribute: "Variables",
+    path: "-/Variables",
+  },
+  Cursor: {
+    name: "Cursors",
+    icon: mdiTableArrowRight,
+    attribute: "Cursors",
+    path: "-/Cursors",
   },
-  Type: { name: "Types", icon: mdiShape, attribute: "Types" },
-  Variable: { name: "Variables", icon: mdiVariable, attribute: "Variables" },
-  Cursor: { name: "Cursors", icon: mdiTableArrowRight, attribute: "Cursors" },
   Package: {
     name: "Packages",
     icon: mdiFileCodeOutline,
     attribute: "Packages",
     color: "#E53935",
+    path: "-/Packages",
   },
   Procedure: {
     name: "Procedures",
     icon: mdiCodeBraces,
     attribute: "Procedures",
     color: "#FF9E4D",
+    path: "-/Procedures",
   },
   Function: {
     name: "Functions",
     icon: mdiFunction,
     attribute: "Functions",
     color: "#FFF176",
+    path: "-/Functions",
   },
   Trigger: {
     name: "Triggers",
     icon: mdiTableCog,
     attribute: "Triggers",
+    path: "-/Triggers",
   },
   JavaSource: {
     name: "JavaSources",
     icon: mdiLanguageJava,
     attribute: "JavaSources",
+    path: "-/JavaSources",
   },
   DatabaseLink: {
     name: "DatabaseLinks",
     icon: mdiAt,
     attribute: "DatabaseLinks",
+    path: "-/DatabaseLinks",
   },
   Synonym: {
     name: "Synonyms",
     icon: mdiArrowTopRightBoldBoxOutline,
     attribute: "Synonyms",
+    path: "-/Synonyms",
+  },
+  Job: {
+    name: "Jobs",
+    icon: mdiDatabaseClock,
+    attribute: "Jobs",
+    path: "-/Jobs",
   },
-  Job: { name: "Jobs", icon: mdiDatabaseClock, attribute: "Jobs" },
   SchedulerJob: {
     name: "SchedulerJobs",
     icon: mdiDatabaseClock,
     attribute: "SchedulerJobs",
+    path: "-/SchedulerJobs",
   },
   Column: {
     name: "Columns",
@@ -306,13 +341,14 @@ function formatDefinition(obj) {
  * - `SAKILA` for a schema object
  * - `SAKILA/Tables` for all tables having `SAKILA` as Schema attribute.
  * - `-/Tables` for all tables, without schema filtering.
+ * - `-/Tables/-/Indexes` for all indexes, without schema nor table filtering.
  * - `SAKILA/Packages/CUSTOMERS/Functions/GET_CUSTOMER` to get component of a package.
 
  */
-export function find(obj, path) {
+export function find(model, path) {
   // Case empty path -> root object.
   if (path === "") {
-    return Object.keys(obj).length != 0 ? obj : undefined;
+    return Object.keys(model).length != 0 ? model : undefined;
   }
 
   // Remove leading slash if present
@@ -320,48 +356,69 @@ export function find(obj, path) {
     path = path.slice(1);
   }
 
+  // Schema⋅s only
   if (!path.includes("/")) {
-    if (path === "-") {
-      // Case all Schemas
-      path = "-/Schemas";
-    } else {
-      // Case bare schema name
-      path = `-/Schemas/${path}`;
-    }
+    path = path === "-" ? "-/Schemas" : `-/Schemas/${path}`;
   }
 
-  let [schema, ...segments] = path.split("/");
-
-  for (const segment of segments) {
-    if (Array.isArray(obj)) {
-      obj = obj.filter((o) => o.Name === segment);
-      // If no objects are found, return undefined
-      if (obj.length === 0) return undefined;
-      // Returns the single object if only one found
-      if (obj.length === 1) {
-        obj = obj[0];
-      } else {
-        // homonyms, stop loop and let UI present the ambiguity
-        return obj;
-      }
-    } else if (typeof obj === "object" && obj !== null) {
-      obj = obj[segment];
-      if (!Array.isArray(obj)) {
-        // refuse non array of dbobjects
+  const parts = path.split("/");
+  const [schema, type, ...rest] = parts;
+
+  // Special case for schema name only
+  if (type === "Schemas") {
+    return parts[2]
+      ? model.Schemas?.find((s) => s.Name && s.Name == parts[2])
+      : model.Schemas;
+  }
+
+  function resolve(current, index) {
+    if (current === null) return undefined;
+
+    // Last segment
+    if (index == rest.length) {
+      // Forbid primitives (ie. not object or array)
+      return typeof current === "object" ? current : undefined;
+    }
+
+    const segment = rest[index];
+
+    if (segment === "-") {
+      const arr = Array.isArray(current) ? current : [current];
+      const results = arr
+        .map((item) => resolve(item, index + 1))
+        .flat()
+        .filter((x) => x !== undefined);
+      return results.length ? results : undefined;
+    }
+
+    // Array lookup by Name
+    if (Array.isArray(current)) {
+      const matches = current.filter((item) => item.Name === segment);
+      if (matches.length === 0) return undefined;
+      if (matches.length > 1 && index < rest.length - 1) {
+        console.error("Invalid path");
         return undefined;
       }
-      // Filter by schema if provided
-      if (schema !== "-") {
-        obj = obj.filter((s) => s.Schema === schema);
-        // Then, disable schema filtering for children.
-        schema = "-";
-      }
-    } else {
-      return undefined;
+      return matches.length > 1
+        ? matches // homonyms
+        : resolve(matches[0], index + 1);
+    }
+
+    // Object lookup
+    if (typeof current === "object") {
+      return resolve(current[segment], index + 1);
     }
+
+    return undefined;
   }
 
-  return obj;
+  // Starting point: Tables, Packages, etc.
+  const collection = model[type];
+  if (!collection) return undefined;
+
+  const filtered =
+    schema === "-" ? collection : collection.filter((o) => o.Schema === schema);
+  return resolve(filtered, 0);
 }
 
 export function expandParents(path) {
diff --git a/internal/cmd/ui/src/test/find.test.js b/internal/cmd/ui/src/test/find.test.js
index c7c3075c07f65663b2885fe984904b67f29da607..0229a1309adf2ccf3b87fc9c02c1e3eefd548b74 100644
--- a/internal/cmd/ui/src/test/find.test.js
+++ b/internal/cmd/ui/src/test/find.test.js
@@ -19,15 +19,43 @@ const obj = {
         {
           Name: "ACTOR_ID",
         },
+        {
+          Name: "ACTOR_LAST_NAME",
+        },
+      ],
+      Indexes: [
+        {
+          Name: "IDX_ACTOR_ID",
+        },
       ],
     },
     {
       Schema: "SAKILA",
       Name: "USER",
+      Columns: [
+        {
+          Name: "USER_ID",
+        },
+      ],
+      Indexes: [
+        {
+          Name: "IDX_USER_ID",
+        },
+      ],
     },
     {
       Schema: "XTRA",
       Name: "USER",
+      Columns: [
+        {
+          Name: "USER_ID",
+        },
+      ],
+      Indexes: [
+        {
+          Name: "IDX_USER_ID",
+        },
+      ],
     },
   ],
 
@@ -37,9 +65,16 @@ const obj = {
       Name: "CUSTOMERS",
       Functions: [
         {
-          Schema: "",
           Name: "GET_CUSTOMER",
         },
+        {
+          Name: "GET_CUSTOMER_RENTAL_HISTORY",
+          Signature: "INT",
+        },
+        {
+          Name: "GET_CUSTOMER_RENTAL_HISTORY",
+          Signature: "INT",
+        },
       ],
     },
   ],
@@ -72,11 +107,11 @@ test("find all schemas", () => {
 
 test("find named schema", () => {
   const result = find(obj, "SAKILA");
-  const result2 = find(obj, "-/Schemas/SAKILA");
-
   expect(typeof result).toBe("object");
   expect(Array.isArray(result)).toBe(false);
   expect(result.Name).toBe("SAKILA");
+
+  const result2 = find(obj, "-/Schemas/SAKILA");
   expect(result).toEqual(result2);
 });
 
@@ -115,15 +150,26 @@ test("find component by name", () => {
   expect(typeof result).toBe("object");
   expect(Array.isArray(result)).toBe(false);
   expect(result.Name).toBe("GET_CUSTOMER");
-  expect(result.Schema).toBe("");
 });
 
 test("find homonyms components", () => {
-  const result = find(obj, "-/Tables/USER/Columns");
+  const result = find(obj, "-/Tables/USER");
   expect(Array.isArray(result)).toBe(true);
   expect(result.length).toBe(2);
   expect(result[0].Name).toBe("USER");
   expect(result[1].Name).toBe("USER");
+
+  const result2 = find(obj, "-/Tables/USER/Columns");
+  expect(result2).toBe(undefined);
+
+  const result3 = find(
+    obj,
+    "SAKILA/Packages/CUSTOMERS/Functions/GET_CUSTOMER_RENTAL_HISTORY",
+  );
+  expect(Array.isArray(result3)).toBe(true);
+  expect(result3.length).toBe(2);
+  expect(result3[0].Name).toBe("GET_CUSTOMER_RENTAL_HISTORY");
+  expect(result3[1].Name).toBe("GET_CUSTOMER_RENTAL_HISTORY");
 });
 
 describe("find non-component attribute", () => {
@@ -142,3 +188,15 @@ describe("find non-component attribute", () => {
     expect(result).toBe(undefined);
   });
 });
+
+test("find indexes for all tables", () => {
+  // for all schemas
+  const result = find(obj, "-/Tables/-/Indexes");
+  expect(result.length).toBe(3);
+  expect(Array.isArray(result)).toBe(true);
+
+  // for a given schema
+  const result2 = find(obj, "SAKILA/Tables/-/Indexes");
+  expect(result2.length).toBe(2);
+  expect(Array.isArray(result)).toBe(true);
+});