diff --git a/src/components/databases.rs b/src/components/databases.rs
index 218ec48..9e357ef 100644
--- a/src/components/databases.rs
+++ b/src/components/databases.rs
@@ -36,7 +36,7 @@ pub enum Focus {
 pub struct DatabasesComponent {
     tree: DatabaseTree,
     filter: DatabaseFilterComponent,
-    filterd_tree: Option<DatabaseTree>,
+    filtered_tree: Option<DatabaseTree>,
     scroll: VerticalScroll,
     focus: Focus,
     key_config: KeyConfig,
@@ -47,7 +47,7 @@ impl DatabasesComponent {
         Self {
             tree: DatabaseTree::default(),
             filter: DatabaseFilterComponent::new(),
-            filterd_tree: None,
+            filtered_tree: None,
             scroll: VerticalScroll::new(false, false),
             focus: Focus::Tree,
             key_config,
@@ -63,7 +63,7 @@ impl DatabasesComponent {
             None => pool.get_databases().await?,
         };
         self.tree = DatabaseTree::new(databases.as_slice(), &BTreeSet::new())?;
-        self.filterd_tree = None;
+        self.filtered_tree = None;
         self.filter.reset();
         Ok(())
     }
@@ -73,7 +73,7 @@ impl DatabasesComponent {
     }
 
     pub fn tree(&self) -> &DatabaseTree {
-        self.filterd_tree.as_ref().unwrap_or(&self.tree)
+        self.filtered_tree.as_ref().unwrap_or(&self.tree)
     }
 
     fn tree_item_to_span(
@@ -168,10 +168,9 @@ impl DatabasesComponent {
             .draw(f, chunks[0], matches!(self.focus, Focus::Filter))?;
 
         let tree_height = chunks[1].height as usize;
-        let tree = if let Some(tree) = self.filterd_tree.as_ref() {
-            tree
-        } else {
-            &self.tree
+        let tree = match self.filtered_tree.as_ref() {
+            Some(t) => t,
+            None => &self.tree,
         };
         tree.visual_selection().map_or_else(
             || {
@@ -223,40 +222,40 @@ impl Component for DatabasesComponent {
     }
 
     fn event(&mut self, key: Key) -> Result<EventState> {
-        if key == self.key_config.filter && self.focus == Focus::Tree {
-            self.focus = Focus::Filter;
-            return Ok(EventState::Consumed);
-        }
-
         if matches!(self.focus, Focus::Filter) {
-            self.filterd_tree = if self.filter.input.value_str().is_empty() {
-                None
-            } else {
-                Some(self.tree.filter(self.filter.input.value_str()))
-            };
-        }
-
-        match key {
-            Key::Enter if matches!(self.focus, Focus::Filter) => {
-                self.focus = Focus::Tree;
-                return Ok(EventState::Consumed);
-            }
-            key if matches!(self.focus, Focus::Filter) => {
-                if self.filter.event(key)?.is_consumed() {
+            match key {
+                Key::Enter => {
+                    self.focus = Focus::Tree;
                     return Ok(EventState::Consumed);
                 }
+                key => {
+                    if self.filter.event(key)?.is_consumed() {
+                        let filter_str = self.filter.input.value_str();
+
+                        self.filtered_tree = if filter_str.is_empty() {
+                            None
+                        } else {
+                            Some(self.tree.filter(filter_str))
+                        };
+                        return Ok(EventState::Consumed);
+                    }
+                }
             }
-            key => {
-                if tree_nav(
-                    if let Some(tree) = self.filterd_tree.as_mut() {
-                        tree
-                    } else {
-                        &mut self.tree
-                    },
-                    key,
-                    &self.key_config,
-                ) {
-                    return Ok(EventState::Consumed);
+        } else if matches!(self.focus, Focus::Tree) {
+            match key {
+                key => {
+                    if key == self.key_config.filter {
+                        self.focus = Focus::Filter;
+                        return Ok(EventState::Consumed);
+                    }
+                    let tree_for_nav = match self.filtered_tree.as_mut() {
+                        Some(tree) => tree,
+                        None => &mut self.tree,
+                    };
+
+                    if tree_nav(tree_for_nav, key, &self.key_config) {
+                        return Ok(EventState::Consumed);
+                    }
                 }
             }
         }
@@ -376,7 +375,7 @@ mod test {
     }
 
     #[test]
-    fn test_filterd_tree_item_to_span() {
+    fn test_filtered_tree_item_to_span() {
         const WIDTH: u16 = 10;
         assert_eq!(
             DatabasesComponent::tree_item_to_span(