marmelab/react-admin

Features

• Administrative Dashboards - Provides a comprehensive framework for building data-driven administrative dashboards with pre-built components for listing and editing records.
• Data Management Interfaces - Constructs comprehensive list, edit, and show views for records with built-in support for filtering, sorting, and validation.
• Complex Datagrids - Renders complex tabular data with support for sorting, filtering, pagination, and advanced grid features.
• CRUD Interfaces - Provides standardized interfaces for listing, creating, editing, showing, and deleting records by mapping resources to API endpoints.
• Record Management Interfaces - Provides form components with built-in validation to capture, update, and manage structured data entries.
• Admin Panel Generators - Automatically generates administrative input fields and layouts by analyzing API schemas.
• API Request Authentication - Automatically injects security credentials into outgoing network headers to authorize communication between the application and backend services.
• Administrative Dashboards - Provides pre-built components for constructing complex, responsive administrative dashboards that visualize and manage backend data.
• Admin Dashboards - Allows embedding full administrative dashboard suites into larger applications via catch-all routing.
• Data List Managers - Displays collections of records with built-in support for filtering, sorting, and pagination to help users navigate large datasets.
• Admin Panel Frameworks - Serves as a specialized framework for building production-ready administrative interfaces with built-in CRUD and authentication.
• CRUD Application Generators - Automatically generates consistent list, create, and edit interfaces for data resources from backend API schemas.
• Resource-Based Routing Engines - Provides a declarative routing system that maps application views directly to data entities and resource structures.
• Typed Data Collections - Fetches and renders collections of records with built-in support for filtering, sorting, and pagination.
• Authentication and Authorization - Manages user authentication and authorization for administrative resources through custom providers.
• Role-Based Access Control - Enforces granular access control by restricting UI visibility and functionality based on user roles.
• User Access Management - Centralizes user access management by validating credentials and roles against authentication providers.
• Administrative Site Generators - Analyzes data structures to infer relationships and render functional display, list, or edit pages to accelerate the initial development of administrative dashboards.
• Component-Based UI Libraries - Offers a collection of reusable components that map backend API resources to list, edit, and show views.
• Declarative Component-Driven Interfaces - Provides a library of pre-built components that manage data fetching and state for administrative dashboards.
• Dashboard Layouts - Assembles administrative dashboards using pre-built structural components like menus, headers, and sidebars for consistent navigation.
• Data Table Customizations - Renders sortable, searchable tables with support for sticky headers and collapsible row details.
• Form and Input Management - Generates input interfaces for editing or creating records with built-in validation and state management.
• Edit View Scaffolding - Configures list, edit, and create interfaces by assembling modular components into consistent layouts.
• CRUD Generators - Analyzes API responses to generate functional CRUD interfaces and boilerplate code for rapid development.
• Data Access Providers - Connects frontend applications to diverse backend services through a standardized adapter architecture for consistent data fetching.
• Data Action Triggers - Executes data provider operations to persist new resource entries to the backend API.
• Data Query Filters - Provides interactive forms and buttons to refine displayed records based on specific field criteria or full-text search queries.
• Data Update APIs - Synchronizes data across clients using pub-sub mechanisms to display live changes and record locks without manual page refreshes.
• Offline Data Management - Caches data locally to allow users to continue working without an active network connection and syncs changes when back online.
• Realtime Synchronization - Synchronizes data across clients using pub-sub mechanisms to display live changes and notifications without manual page refreshes.
• Pagination Utilities - Retrieves collections of records from an API with support for filtering, sorting, and pagination to manage large datasets.
• Real-time Data Synchronization - Synchronizes data across clients by displaying live notifications and automatically refreshing content when backend records change.
• Record Deletion - Enables the removal of individual data records from the backend via unique identifiers.
• Live Update Subscriptions - Establishes real-time connections to automatically update lists when backend records change.
• Search and Indexing - Enables multi-criteria search and filtering on list views by mapping input components directly to API query parameters.
• Search Result Filtering - Provides interactive controls to narrow down list results through sidebar filters or form-based inputs that update data queries.
• Single Record Retrievers - Fetches and renders specific data records to provide context for detail views and page layouts.
• Unified Data Provider Interfaces - Provides a unified data provider interface that translates high-level CRUD actions into specific network requests for various backends.
• Internationalization Support - Provides comprehensive internationalization support for translating text with pluralization and interpolation.
• Application Generators - Generates pre-configured project structures with essential dependencies to accelerate administrative dashboard development.
• View - Analyzes API responses to automatically generate and suggest the necessary UI components for displaying a data collection.
• Reactive Collection Sync - Reflects live backend data changes in the user interface using pub/sub mechanisms.
• Bearer Token Authentication - Automatically attaches authentication tokens to API request headers for secure communication.
• Identity Authentication - Connects to external identity providers to verify user credentials and manage session state across the application.
• Component-Level Access Evaluation - Allows programmatic evaluation of access rights within components to conditionally render UI elements or restrict navigation.
• Session Authentication - Triggers authentication providers to verify credentials and establish secure sessions for protected administrative resources.
• Session Token Refreshers - Maintains secure sessions by implementing automated token refresh logic for user authentication.
• Access Authentication - Enforces application-wide login requirements by securing data resources and custom pages.
• Modular Data Adapters - Uses a modular adapter architecture to decouple frontend data operations from diverse REST or GraphQL backend services.
• Permission-Based UI Rendering - Retrieves authorization levels to conditionally display content or restrict actions within administrative pages.
• Step-Level Access Validation - Validates user permissions for individual form sections and displays custom feedback or loading states when access is denied.
• Resource Routing - Maps URL patterns to data resources and injects context for automated component operations.
• Event-Based Authorization - Provides asynchronous authorization checks triggered by user interactions to validate access to resources and actions.
• Context Providers - Implements context providers to inject record data into component trees, enabling decoupled access to record properties.
• Data Display Components - Maps data sources to visual components for rendering record properties in user interfaces.
• Calendar Views - Provides interactive calendar interfaces for visualizing and managing time-based records.
• Data Entry Forms - Constructs administrative forms using pre-built input components and layout wrappers that automatically handle validation, submission, and state management for user input.
• Complex Form Layouts - Organizes complex data entry tasks into manageable sequences of steps.
• Data View Configuration - Analyzes data structures to automatically generate functional tables and provide code snippets for custom interfaces.
• Form Validation - Executes synchronous and asynchronous validation logic on form inputs with automatic error message display.
• Input Validation Rules - Applies custom or built-in validation rules to form fields to ensure data integrity before submission.
• Form Management - Supports sophisticated data entry workflows with built-in validation, multi-step forms, and dynamic field dependencies.
• Administrative Edit Forms - Constructs administrative forms that handle record fetching, data transformation, and submission lifecycle management.
• Forms - Constructs complex input layouts with built-in validation and automatic data binding to the underlying record state.
• Interface Localization - Translates application text into multiple languages using configurable language settings and message bundles.
• Declarative Schemas - Automatically generates form layouts and validation logic by analyzing API schemas and data structures.
• Form Input Components - Offers a collection of specialized components for capturing various data types within administrative forms.
• Visual Theme Configurations - Enables global visual style configuration through theme objects and pre-built design presets.
• API Adapters - Provides modular adapters that normalize diverse REST or GraphQL API responses into a unified format for administrative interfaces.
• Headless Creation Controllers - Provides headless containers for managing form submission and data context for creating new records without enforcing UI layouts.
• Data Fetching & Caching - Fetches and caches remote data in the background with automatic retries to ensure the interface remains consistent with the backend.
• Data Fetching Hooks - Fetches API data while automatically managing loading, error, and state for user interface components.
• Data Fetching Optimizers - Automatically fetches and displays related records by resolving foreign keys and deduplicating requests to optimize network performance.
• State & Data Management - Provides specialized page components and hooks to fetch, display, and modify records from an API while managing state through shared contexts.
• Integration APIs - Connects to external REST or GraphQL backends through a modular adapter architecture for flexible data fetching.
• Optimistic Updates - Updates the user interface immediately after interactions while managing background requests to provide a responsive, optimistic experience.
• Core Frameworks - Frontend framework for building B2B and CRUD applications.
• Developer Utilities - Framework for building admin panels on top of REST/GraphQL APIs.
• Frameworks - Frontend framework for building complex B2B and admin interfaces.
• Integration and Admin Frameworks - Framework for creating React-based admin GUIs for APIs.
• UI Frameworks - Framework for building admin interfaces over REST/GraphQL.
• Headless Form Containers - Provides headless form containers that manage state and validation for custom administrative layouts.
• Client-Side Storage Persistence - Saves form input values to browser storage to prevent data loss during long sessions or accidental navigation.
• Data Fetching - Retrieves a collection of specific records from a data source by providing an array of unique identifiers.
• Document and Record Handling - Handles data fetching, loading states, and resource context automatically for record management.
• State and Context Management - Utilizes React context to propagate record data and controller state throughout the component tree for decoupled UI management.
• Real-Time - Reflects live backend updates in the user interface using pub-sub mechanisms to keep dashboards current without manual refreshes.
• Direct Record Access - Retrieves the current record context for child components to read or manipulate.
• Related Record Selectors - Provides interfaces to create, update, or delete records within a one-to-many relationship directly from the parent view.
• Singleton Record Managers - Interfaces for editing single database records by binding forms to specific query results and managing save callbacks.
• Row Record Access - Retrieves the current record from context to provide data to child components for rendering.
• Local State Caches - Maintains a local mirror of remote data to enable instant interface updates and automatic synchronization across different views.
• Record Detail Modals - Renders a collection of data fields in a structured layout, automatically associating labels with each field.
• Optimistic Mutation Handlers - Supports configurable mutation strategies including optimistic updates and undoable actions to balance responsiveness and data consistency.
• Related Record Importers - Fetches and renders lists of related records associated with a parent entity via foreign key arrays.
• Relational Data Management - Provides specialized components to edit or associate records from different resources within a single interface or modal.
• Relationship Management - Fetches and links records from related resources to populate selection inputs while handling data loading and state synchronization.
• Project Scaffolding and Configuration - Initializes data providers, authentication strategies, and resource definitions during project creation.
• HTTP Request Abstractions - Uses a data provider abstraction to convert high-level application methods into specific network requests for diverse backends.
• Access Control Lists - Validates permissions against resources before rendering list data to prevent unauthorized access.
• Interface Element Visibility - Conditionally renders interface components and menu items based on user authorization status.
• Authentication Managers - Provides hooks and components to manage authentication state and protect routes based on user sessions.
• External Identity Provider Integration - Integrates with third-party OAuth and identity providers to manage user sessions and authentication callbacks.
• Field-Level Read Restrictions - Conditionally hides specific data fields from users based on their authorization status.
• Customizable Login Interfaces - Allows full customization of login interfaces to support branded authentication flows like SSO or MFA.
• Tab Access Restrictions - Hides specific tabs and their contents based on user permissions to ensure sensitive information is only visible to authorized roles.
• Record-Level Filtering - Limits user permissions to specific data entries by matching record attributes against defined access rules.
• Third-Party Authentication Providers - Integrates third-party identity providers to manage user sessions, login flows, and access control.
• Authentication Redirects - Validates user credentials via custom providers and redirects unauthorized users to login pages.
• Accessible Interaction Toolkits - Provides headless hooks and controllers for managing state and API interactions without enforcing a specific visual design.
• Color Themes - Overrides default styles, fonts, and colors to match branding, including support for light and dark mode switching.
• Bulk Selection Operations - Enables users to select multiple rows and execute operations like deletion or updates on the entire selection simultaneously.
• Collection Item Controllers - Manages nested object collections within records using sub-form interfaces for adding, removing, and reordering items.
• Form Data Persistence - Saves form inputs to the backend in the background during data entry to prevent data loss and reduce manual submission requirements.
• Schema-Based Generators - Automatically renders administrative forms by parsing JSON schema definitions.
• Custom Layouts - Enables the design of bespoke application shells and navigation structures to match specific branding requirements.
• Automated List Generators - Inspects data structures to automatically generate list views and boilerplate code for administrative dashboards.
• Search Filters - Provides components for building search interfaces with support for saving personal filter combinations that persist across user sessions.
• Theme Customization - Provides interfaces for overriding default styles and branding to modify the visual appearance of the entire application.
• UI Components - Enables building complex interfaces by nesting specialized components for data display, input, and layout within a unified context.
• UI Composition - Supports building complex administrative interfaces by composing modular, context-aware UI components.
• API Integrations - Integrates remote REST or GraphQL backends through a standardized interface designed for administrative applications.
• Cloud API Request Execution - Performs authenticated network calls by automatically managing headers, content types, and structured error handling.
• Custom Page Frameworks - Supports the creation of custom dashboard views that integrate seamlessly with the existing application layout.
• Form Submission Clients - Triggers form submission to the backend by invoking save functions within the form context.
• Form Validation Libraries - Enforces data integrity using custom functions and schema-based validation for form fields and submissions.
• API Connection Managers - Handles authentication, data fetching, and state management through standardized adapters for backend connectivity.
• Saved Views - Allows users to save specific combinations of filters and sort parameters as named presets that remain available across sessions.
• Custom Data Source Integrations - Implements standardized methods to connect administrative interfaces with any REST or GraphQL backend.
• Data Resource Management - Retrieves and displays total record counts for resources from the data provider without loading individual rows.
• Record-to-Page Bindings - Retrieves record and controller state for specific resources to render administrative detail views.
• In-Place Data Modifiers - Provides spreadsheet-style interfaces for modifying data directly within table rows without navigating to separate detail pages.
• Inline Data Editing - Enables spreadsheet-style direct editing of records within tabular data interfaces.
• Query Population - Populates selection choices dynamically by fetching related records from external APIs.
• Record Updating - Supports bulk record updates by sending multiple identifiers and data payloads to the backend simultaneously.
• Related Attribute Resolvers - Aggregates and deduplicates requests for foreign key relationships to optimize data retrieval and display in the user interface.
• Soft Deletion - Marks a record as deleted in the database instead of permanently removing it, allowing for data recovery through specialized provider calls.
• User Preference Persistence - Persists user settings like themes and layouts in local storage to maintain consistency across sessions.
• Application Behavior Configurations - Allows fine-grained configuration of caching, refetching, and retry logic for data operations to optimize application performance.
• API Integrations - Translates application actions into specific API requests to enable connectivity with diverse backend services.
• Route-Level Bypass - Enables public viewing of administrative data by bypassing authentication requirements for specific resource routes.
• List State Accessors - Exposes pagination, sorting, and filter settings to allow developers to build custom search bars and action menus.
• User Identity Management - Manages user identity details to personalize the interface and adapt component behavior.
• User Profile Retrieval - Fetches profile information of the authenticated user to display within the administrative interface.
• Persistence Automation - Automatically saves form content to local storage to prevent data loss during inactivity or navigation.
• Concurrency Control - Prevents data conflicts by restricting access to editing records currently being modified by other users.
• Headless Logic Controllers - Exposes low-level hooks for business logic and state management to enable custom UI component development.
• Application Audit Logs - Tracks and displays user interaction logs to ensure operational visibility and compliance.
• Alerts & Notifications - Triggers real-time visual alerts and status updates in the interface based on backend events.
• Column Management Interfaces - Allows end users to show, hide, and reorder table columns dynamically with support for persistent storage.
• Component Replacements - Allows swapping built-in UI elements or logic controllers with custom implementations.
• Live Filter Modifiers - Updates data query parameters in real-time as users modify form inputs to provide immediate filtered feedback.
• Date Pickers - Collects date values through locale-aware picker components.
• Dynamic Input Forms - Updates or toggles the visibility of form fields dynamically based on the values of other inputs to manage complex workflows.
• Field Customization - Creates reusable field components that access record context to render complex data or links to related resources.
• Filter Active Indicators - Displays active search and filter criteria as interactive chips for clear visibility of current data constraints.
• Form Submission Management - Injects a custom callback into the save context to intercept or replace the default data persistence behavior during form submission.
• High-Performance Rendering - Uses virtualization to maintain smooth scrolling and high performance when displaying large datasets by rendering only visible items.
• Infinite Scroll Components - Implements infinite scrolling to automatically load and append records as users reach the end of a list.
• Interface Layout Customization - Defines the visual structure of the dashboard, including navigation menus, headers, and sidebars, using built-in or custom components.
• Headless Edit Containers - Enables the design of custom administrative editing interfaces by providing headless data-fetching and submission management.
• Headless List Containers - Provides headless containers for fetching and managing record collections in custom list interfaces.
• Pagination Controls - Provides navigation controls for browsing large datasets through discrete, sequential pages.
• Page Action Integrations - Allows replacing default toolbar buttons with custom components for specific workflows.
• Responsive Layout Adapters - Adjusts layouts and component behavior automatically for mobile and desktop devices to ensure a responsive user experience.
• Searchable Filter Inputs - Updates the current data view automatically as a user types into a search field to refine displayed results.
• Searchable Select Inputs - Provides searchable dropdown interfaces for selecting multiple items from lists.
• View Layouts - Assembles standard dashboard pages by wrapping form content with titles, action buttons, and layout containers to ensure a consistent user interface.
• API Bridges - Provides data adapters to link frontend interfaces with custom REST or GraphQL backends.
• Routing Configurations - Supports swapping the underlying routing library to integrate with different navigation frameworks while maintaining a consistent interface.
• Navigation Path Generators - Generates application links that automatically account for sub-path mounting and base URL prefixes.
• Creation Containers - Provides structured containers for administrative form submission and layout management during record creation.
• Data Relational Mappers - Deduplicates and combines requests for related records across lists to minimize network traffic and accelerate data rendering.
• List Sorting Selectors - Allows users to reorder records by clicking column headers or using custom sort controls.
• Data Source Routing - Directs data queries to different backend providers based on the requested resource to support multi-source applications.
• Database-to-REST Interfaces - Synchronizes data across various REST, GraphQL, and local storage APIs using a standardized interface.
• Database Existence Validators - Validates field uniqueness by querying the backend for existing records before allowing form submission.
• File Upload Management - Handles file uploads and management within administrative forms.
• Hierarchical Data Models - Manages and displays hierarchical data structures as tree interfaces for editing and navigation.
• Annotation Save Interceptors - Executes custom logic before or after data mutations by wrapping the save process to transform data or manage related records.
• Relationship Field Mappers - Accesses and renders nested object data using dot-notation paths without requiring additional API requests.
• Persistent Application State - Persists user preferences and local application data across sessions to maintain a personalized experience.
• Relationship Count Aggregators - Calculates and displays the total count of related records for a parent entity without fetching the full dataset.
• Batch Data Fetchers - Aggregates multiple record requests into single queries to reduce network overhead when displaying related data.
• List State Persisters - Maintains user context by persisting list filters and sorting parameters across navigation.
• API Error Handling - Maps backend validation errors to specific form fields or global notifications to provide user-facing feedback.
• Global Application Contexts - Injects specific data objects into the layout to display information independently of global state.
• Lifecycle Hooks - Triggers custom logic during data operations to perform validation, reference counting, or automated state updates.
• Record - Maintains a history of record changes, enabling users to browse, compare, and restore previous data versions.
• Task Schedulers - Manages events and time-based resources with drag-and-drop capabilities in a high-performance scheduling interface.
• Task Scheduling - Displays events and dependencies in a timeline interface with support for grouping, filtering, and recurring events.
• Authentication Providers - Provides access to authentication providers from the application context for login, logout, and permission checks.
• Content Sanitization - Sanitizes HTML content to prevent cross-site scripting before rendering to the interface.
• Data and Resource Permissions - Evaluates authorization status for multiple resources simultaneously to determine access for collections.
• Deny-List Policies - Supports explicit access denial to override broad permissions for specific resources.
• Navigation Guards - Prompts users to confirm navigation when unsaved form changes are detected to prevent data loss.
• Session Termination Services - Clears authentication state and triggers the logout process to end active user sessions.
• Hierarchical Data Structures - Retrieves tree-structured records from an API and flattens them into an array for use within administrative dashboard components.
• Authentication Success Callbacks - Handles authentication callbacks from external services by processing query parameters and managing redirects.
• User Action Interceptors - Implements undoable data mutations by delaying requests and providing a grace period for user reversal.
• Declarative Record Views - Renders a record property as plain text by extracting the value from the current data context and displaying it within the user interface.
• List Filtering Utilities - Displays a dropdown menu that allows users to select and inject additional input fields into a data list filter form.
• Data View Customizers - Provides headless hooks and base components for building custom data views without enforcing specific UI layouts.
• Date and Time Pickers - Provides components for capturing temporal date and time data.
• Date Selection Components - Captures date range intervals for filtering records with locale support.
• Custom Field Renderers - Combines data from multiple record sources into a single view using custom rendering logic.
• Column - Provides mechanisms to hide or show table columns based on user permissions.
• Creation Context Providers - Exposes submission callbacks and form state to descendant components, facilitating custom UI interactions during record creation.
• Localized Form Components - Supports multi-language interfaces by localizing form labels and validation messages.
• Hierarchical Data Templates - Displays nested information in a collapsible tree structure to help users navigate and manage parent-child relationships within a dataset.
• Layout Configurations - Allows swapping default navigation structures for custom implementations to control how the application interface is organized.
• List Rendering - Exposes list records and metadata to custom components via render functions for specialized visualizations.
• Modal Editing Interfaces - Opens an editing interface within a modal window to modify data without navigating away from the current page or changing the browser URL.
• Custom Navigation Items - Supports adding custom links to the application menu system for improved navigation and discovery.
• Notification Toasts - Provides transient toast-style notifications to give users immediate feedback on application actions and system events.
• Information Sidebars - Displays supplementary information or context-aware widgets in dedicated sidebar areas.
• Custom Option Renderers - Allows defining custom visual templates and filtering logic for dropdown suggestion options.
• Multi-Select Inputs - Allows users to select and edit multiple scalar values simultaneously.
• Selection Dialogs - Opens modal interfaces for selecting records from paginated data tables.
• Sidebars - Displays selectable filter categories in a side panel to allow users to quickly toggle and combine multiple data constraints.
• Style Configurations - Adjusts the look and feel of the application interface through theme configurations and style overrides to match branding requirements.
• Component Style Overrides - Applies custom CSS properties directly to individual interface elements using a dedicated styling prop.
• Interface Appearance Customization - Adjusts the look and feel of the application interface using style overrides and theme configurations to match branding requirements.
• View Customizations - Provides headless containers that fetch records and manage form submission state, allowing developers to design custom administrative editing interfaces without pre-built layout constraints.
• Administrative API Endpoints - Maps application data operations to specific API endpoints for consistent CRUD record management.
• API Request Handling - Provides hooks to trigger notifications, redirects, or data refreshes automatically upon the completion or failure of API requests.
• Custom API Executors - Extends standard data interfaces to support non-CRUD operations and specialized backend actions.
• Data Transformation Utilities - Converts data between the format required by the user interface and the format expected by the backend API.
• Dynamic Visibility Controllers - Shows or hides specific fields dynamically based on the values of other record properties within a view.
• Infinite Data Fetching - Retrieves sequential pages of records from an API and provides controls to load additional data for continuous content feeds.
• Lazy Loading - Splits application code into smaller bundles that download on demand to improve initial load times and performance.
• Navigation Redirects - Navigates users to specific application locations using direct paths or dynamic state-based generation.
• Nested Routing - Defines sub-routes within existing resource paths to organize related data views or hierarchical content structures.
• Programmatic Prefetching - Loads referenced records alongside the main query to eliminate visual delays and ensure immediate display of necessary information.
• Real-Time Collaboration Tools - Synchronizes data across clients using pub/sub mechanisms to enable real-time collaboration in administrative dashboards.

Star-Verlauf