laravel nova hide edit button on index page
Stefan Bogdanescu
Founder & Senior Architect · 2026-06-29
# Mastering Context: Hiding UI Elements in Laravel Nova Based on Route
As a senior developer working with Laravel and the Nova administration panel, we often encounter challenges where the User Interface needs to adapt dynamically based on the current context—whether the user is viewing a list (index) or a specific record (detail). A very common scenario is needing to hide destructive actions like "Edit" or "Delete" buttons on an index page while keeping those actions fully accessible on the detail view.
This post dives into how you can achieve this conditional UI hiding in Nova, moving beyond simple authorization policies to control the presentation layer effectively.
## The Challenge: Context-Aware UI Control
The core requirement here is context awareness. You want the same underlying data and permissions (managed by Policies) to govern the *actionability* of a record, but you need to manipulate the *visibility* of the buttons based on the current screen.
If you rely solely on authorization policies, a user who has permission to edit a record will see the edit button everywhere. To hide it selectively, we must intervene in the rendering process. The proposed method—checking the route name within the controller—is one way to achieve this, but let's explore if there is a cleaner, more scalable approach.
### Evaluating the Route Name Approach
The logic you suggested:
```php
public function update(User $user, Customer $customer)
{
if ( request()->route()->getName('route-name') ) {
return false; // Disable action if on the detail page
}
// ... proceed with update logic
}
```
**Is this correct?** Yes, technically it works. It successfully checks the current URL context (`route-name`) and conditionally stops the operation from proceeding.
**Is it the best way?** Not necessarily. While functional for a simple case, tightly coupling UI presentation logic directly into the core controller action can make the code harder to maintain and test, especially in complex applications utilizing frameworks like Nova where resource definitions are often abstracted away. A better practice is to separate concerns: controllers should handle business logic, and views should handle presentation based on passed state.
## The Recommended Approach: Passing State via Resource Context
The most robust pattern for handling context-dependent UI changes in Laravel/Nova is to make the necessary state available to the view layer. Instead of forcing the controller to decide *if* the button should exist, the controller decides *what* the button should display or whether it should be rendered at all.
### Step 1: Modifying the Resource Context (The Nova Way)
When dealing with Nova resources, you often look at how the index view is being populated versus the detail view. You can leverage the context provided by Nova to determine visibility.
In a standard resource setup, if you are only concerned about hiding actions on the index, you need a mechanism to tell the index view that it should render differently. This often involves checking properties or flags associated with the request.
### Step 2: Implementing Conditional Rendering in the View
The actual hiding of the buttons must happen in the Blade file where the Nova resources are rendered. You pass a flag from your controller to this view.
**Controller Example (Setting the State):**
```php
use Illuminate\Http\Request;
class CustomerController extends Resource
{
public function index(Request $request)
{
// Determine if we are on the index page for conditional rendering
$isIndex = $request->route()->getName() === 'customers.index';
// Fetch data as usual...
$customers = Customer::paginate(10);
return $this->collection($customers); // Or return a custom view if necessary
}
public function show(Customer $customer)
{
// On the detail page, we don't need to hide buttons, so we just return the record.
return $this->view('customer.show', ['customer' => $customer]);
}
}
```
**Blade Example (The Conditional Hiding):**
In your Nova view file (e.g., `resources/views/customers/index.blade.php`), you can now check this context variable:
```html
{{-- Inside the table row for each customer --}}
@if (request()->route()->getName() === 'customers.index')
{{-- Only show edit/delete buttons if we are on the index page --}}
Edit
Delete
@else
{{-- On the detail page, hide them entirely --}}
@endif
```
While this still relies on checking the route name in the view, it centralizes the decision logic (which routes require hiding) and separates presentation from complex business rule execution. For truly advanced context management within Nova, exploring how Nova hooks into request lifecycle is key, often involving custom view extensions or service providers, which aligns with best practices promoted by Laravel and its ecosystem, such as what you find on https://laravelcompany.com.
## Conclusion
The method of checking the route name is a pragmatic solution for achieving context-aware UI control in Laravel applications like Nova. However, for cleaner, more scalable code, we strive to keep controllers focused on data flow and views focused purely on presentation based on that data. By passing contextual information (like whether the view is an index or detail) from the controller to the view, you create a separation of concerns that makes your application significantly easier to maintain as it grows. Always aim for clarity and adherence to established architectural patterns when building robust Laravel applications.