awesome-repositories.com
Blog
awesome-repositories.com

Découvrez les meilleurs dépôts open-source grâce à notre recherche par IA.

ExplorerRecherches sélectionnéesAlternatives open sourceLogiciels auto-hébergésBlogPlan du site
ProjetÀ proposNotre méthodologiePresseServeur MCP
Mentions légalesConfidentialitéConditions d'utilisation
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
marmelab avatar

marmelab/react-admin

0
View on GitHub↗
26,780 stars·5,458 forks·TypeScript·MIT·11 vuesmarmelab.com/react-admin↗

React Admin

React-admin is a framework for building data-driven administrative interfaces that connect to REST or GraphQL backends. It provides a comprehensive suite of tools for managing the full lifecycle of administrative applications, including resource-oriented routing, declarative form scaffolding, and context-driven state management. By utilizing a modular adapter-based architecture, the framework abstracts backend communication, allowing developers to build consistent CRUD interfaces that handle data fetching, authentication, and synchronization automatically.

The project distinguishes itself through a highly flexible composition model that supports both rapid development and deep customization. It offers automated view generation by analyzing API schemas, while simultaneously providing headless hooks and controllers for developers who require full control over the user interface and business logic. This dual approach allows for the construction of complex, responsive dashboards that include advanced features like optimistic UI updates, real-time data synchronization, and granular role-based access control.

Beyond core CRUD capabilities, the framework includes a wide range of functional modules for managing sophisticated data entry workflows, hierarchical data structures, and multi-step forms. It supports extensive UI customization through theme overrides, responsive layout configurations, and the ability to integrate custom components or AI-driven features. The system also provides built-in support for internationalization, audit logging, and offline operations, ensuring that administrative applications can meet diverse operational and compliance requirements.

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.

Recherche par IA

Explorez plus de dépôts awesome

Décrivez vos besoins en langage naturel — l'IA classe des milliers de projets open source sélectionnés par pertinence.

Start searching with AI
  • 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.

    • Historique des stars

    Graphique de l'historique des stars pour marmelab/react-adminGraphique de l'historique des stars pour marmelab/react-admin

    Questions fréquentes

    Que fait marmelab/react-admin ?

    React-admin is a framework for building data-driven administrative interfaces that connect to REST or GraphQL backends. It provides a comprehensive suite of tools for managing the full lifecycle of administrative applications, including resource-oriented routing, declarative form scaffolding, and context-driven state management. By utilizing a modular adapter-based architecture, the framework abstracts backend communication, allowing developers to build consistent CRUD…

    Quelles sont les fonctionnalités principales de marmelab/react-admin ?

    Les fonctionnalités principales de marmelab/react-admin sont : Administrative Dashboards, Data Management Interfaces, Complex Datagrids, CRUD Interfaces, Record Management Interfaces, Admin Panel Generators, API Request Authentication, Admin Dashboards.

    Quelles sont les alternatives open-source à marmelab/react-admin ?

    Les alternatives open-source à marmelab/react-admin incluent : filamentphp/filament — Filament is a full-stack framework for building administrative panels and management interfaces within the Laravel… the-control-group/voyager — Voyager is a Laravel administration panel and PHP database manager that provides a web-based dashboard for managing… dpgaspar/flask-appbuilder — Flask-AppBuilder is a rapid application framework built on Flask that automates the creation of admin interfaces and… refinedev/refine — Refine is a headless framework designed for building data-intensive internal business applications, such as admin… theorchid/platform — Platform is a framework for building back-office applications and administrative dashboards using Laravel. It… orchidsoftware/platform — This project is a rapid application development framework for building back-office interfaces and dashboards within…

    Alternatives open source à React Admin

    Projets open source similaires, classés selon le nombre de fonctionnalités partagées avec React Admin.
    • filamentphp/filamentAvatar de filamentphp

      filamentphp/filament

      31,215Voir sur GitHub↗

      Filament is a full-stack framework for building administrative panels and management interfaces within the Laravel ecosystem. It provides a declarative, component-based architecture that allows developers to construct complex, data-driven applications using server-side configuration objects rather than manual HTML. By inspecting database model structures and relationships, the framework automates the generation of CRUD interfaces, forms, and data tables, significantly reducing boilerplate code. The project distinguishes itself through a highly modular and extensible design that supports custo

      PHPadminalpine-jsbuilder
      Voir sur GitHub↗31,215
    • the-control-group/voyagerAvatar de the-control-group

      the-control-group/voyager

      11,819Voir sur GitHub↗

      Voyager is a Laravel administration panel and PHP database manager that provides a web-based dashboard for managing application data and administrative user privileges. It functions as a BREAD CRUD manager, allowing users to browse, read, edit, archive, and delete database records through a graphical interface. The system enables database content management without the need to write custom controller code or execute raw SQL. It includes tools for role-based access control to define and manage administrative permissions, restricting access to backend tools based on assigned user roles.

      PHP
      Voir sur GitHub↗11,819
    • dpgaspar/flask-appbuilderAvatar de dpgaspar

      dpgaspar/Flask-AppBuilder

      4,951Voir sur GitHub↗

      Flask-AppBuilder is a rapid application framework built on Flask that automates the creation of admin interfaces and database-driven applications. It functions as an automatic CRUD generator and a SQL database admin interface, enabling the generation of user interfaces and REST APIs directly from data models. The framework includes a security system for managing user identities and access roles through role-based access control. It supports authentication via internal databases or external providers such as LDAP, OAuth, and OpenID. The platform covers broader capabilities including multi-dia

      Python
      Voir sur GitHub↗4,951
  • refinedev/refineAvatar de refinedev

    refinedev/refine

    34,906Voir sur GitHub↗

    Refine is a headless framework designed for building data-intensive internal business applications, such as admin panels and dashboards. It provides a core set of hooks and architectural patterns that decouple business logic, authentication, and data operations from the user interface, allowing developers to integrate any design system while maintaining a consistent application structure. The framework distinguishes itself through a resource-centric approach that automatically maps application views to data entities via centralized configuration. It features a unified data provider interface

    TypeScriptadminadmin-uiant-design
    Voir sur GitHub↗34,906
    • Voir les 30 alternatives à React Admin→