Passing mutable struct to mutable attribute of struct

I'm building a small TUI tool with ratatui, I want to pass a mutable instance of App to every widget so I can:

• Handle events and update widget data
• Update main App data

Here is a simple structure of my tool

// app.rs
impl App {
	pub fn new() -> Self {
		Self {
			user_input: UserInput::new(),
		}
	}

	pub fn get_curr_widgets(&mut self) -> Vec<&mut dyn Component> {
		vec![
			&mut self.sidebar,
			&mut self.user_input,
		]
	}
}

// src/components/user_input.rs
impl Component for UserInput {
	fn handle_events(&mut self, event: Event, app: &mut App) {
		match event {
			Event::Key(key_event) => match key_event.code {
				// Update App data
				// KeyCode::Enter => app.do_search(),
				// app.widget_index = -1
				KeyCode::Char(to_insert) => {
					// Update UserInput data
					self.enter_char(to_insert);
				}
				_ => {}
			},
			_ => {}
		}
	}
}

// event_handles.rs
pub fn handle_terminal_events(event: Event, app: &mut App) {
	let widget_index = app.widget_index;
	let widgets = app.get_widgets();
	for (index, widget) in app.get_widgets().into_iter().enumerate() {
		if widget_index == index {
			// Error: error[E0499]: cannot borrow `*app` as mutable more than once at a time
			widget.handle_events(event, app);
			break;
		}
	}
}

Full error:

error[E0499]: cannot borrow `*app` as mutable more than once at a time
  --> src/handler.rs:51:43
   |
48 |         let widgets = app.get_widgets();
   |                     --------------- first mutable borrow occurs here
...
51 |                 widget.handle_events(event, app);
   |                      -------------        ^^^ second mutable borrow occurs here
   |                      |
   |                      first borrow later used by call

What I think of the error at line: widget.handle_events(event, app);

• widget. first borrow mutable of App
• then we can't pass the second mutable of App to the function

In Rust, we only can have one mutable ref at a time.
So what are better ways to solve my problem or I'm structuring it wrong?

This smells like a design problem.
Widgets (Components) are enclosed within App but you are trying to mutate the app when handling events at the Component level.

Ideally the code that mutates the App should exist within the "impl App" block.

impl App {
    pub fn new() -> Self {
        Self {
            user_input: UserInput::new(),
        }
    }

    pub fn handle_events(&mut self) {
        let mut widgets = vec![
            &mut self.sidebar,
            &mut self.user_input,
        ];
        for (index, widget) in self.get_widgets().iter_mut().enumerate() {
            if widget_index == index {
                widget.handle_events(event, self);
                break;
            }
        }
    }
}

// src/components/user_input.rs
impl Component for UserInput {
    fn handle_events(&mut self, event: Event, app: &mut App) {
        match event {
            Event::Key(key_event) => match key_event.code {
                // Update App data
                // KeyCode::Enter => app.do_search(),
                // app.widget_index = -1
                KeyCode::Char(to_insert) => {
                    // Update UserInput data
                    self.enter_char(to_insert);
                }
                _ => {}
            },
            _ => {}
        }
    }
}

// event_handles.rs
pub fn handle_terminal_events(event: Event, app: &mut App) {
    app.handle_events();
}

So by this change you are mutating the app within the context(lifetime) of App impl only.

This should resolve the issue.

NOTE: get methods are conventionally used to read(&) not write (&mut).