rails-api/active_model_serializers
Active Model Serializers
Active Model Serializers est un sérialiseur JSON Ruby on Rails utilisé pour transformer des objets de modèle et des associations en réponses JSON structurées pour les API. Il fonctionne comme un mapper modèle-vers-JSON et un formateur de réponse qui découple les schémas de base de données internes des contrats d'API externes.
Le projet utilise un pattern d'adaptateur enfichable pour organiser les données sérialisées selon des standards spécifiques, comme la spécification JSON API. Il fournit un mécanisme pour mapper les attributs internes vers des clés JSON personnalisées et implémente une portée de sérialisation qui permet le filtrage d'attributs et d'associations basé sur le contexte d'autorisation et les permissions utilisateur.
L'ensemble d'outils couvre la transformation de données via l'utilisation d'attributs virtuels et la gestion des données associées via sideloading ou embedding d'ID. Il inclut des capacités pour l'injection de métadonnées de réponse, la mise en cache de résultats basée sur des fragments et l'instrumentation de performance pour suivre les métriques de sérialisation.
Features
- Model to JSON Conversion - Transforms model objects into structured JSON representations for API responses using a customizable process.
- Response Formatting - Transforms database models into structured JSON responses for web APIs using a customizable serialization process.
- Serialization Contexts - Passes an authorization context into the serializer to customize output based on user permissions.
- Authorization-Based - Controls which data fields are visible in a response based on the current user identity or authorization level.
- Nested Serialization - Automatically embeds related database records into API responses by recursively applying serializers.
- Association Definitions - Provides a descriptive language to specify how related models are included and represented in the JSON output.
- Attribute-Based Access Control - Controls which attributes and associations appear in the output based on the current authorization context.
- Serialization Attribute Restrictions - Restricts specific attributes and associations based on the current user identity or authorization level.
- Class Instance JSON Serializers - Transforms model or plain Ruby objects into JSON representations using dedicated serializer classes.
- Adapter-Based Output Formatting - Uses a pluggable adapter pattern to transform internal data structures into specific JSON specifications.
- Computed Properties - Allows the definition of synthetic properties via custom logic within serializer methods.
- Attribute-Mapping Layer - Decouples the external API contract from the internal database schema by mapping model attributes to custom keys.
- Contextual Serialization Logic - Passes external context into the serialization process to filter attributes or associations based on user permissions.
- Model-to-JSON Mappers - Decouples database schemas from API contracts by mapping internal attributes to custom JSON keys.
- Specification Adapters - Uses a pluggable adapter pattern to format JSON responses according to specific API specifications.
- Attribute Key Mapping - Decouples the external API contract from the database schema by mapping internal attributes to custom JSON keys.
- Specification Adapters - Provides a formatting layer that organizes serialized data to follow specific standards like the JSON API specification.
- JSON APIs - Builds API endpoints that adhere to specific data standards using pluggable adapters.
- JSON Structure Adapters - Adjusts the output structure using adapters to satisfy specific API standards or root key requirements.
- Rails JSON Serializers - Transforms Ruby on Rails model objects and associations into structured JSON responses for APIs.
- Relationship Mapping - Defines how associated models are linked or embedded in JSON outputs to manage payload size.
- Resource Sideloading - Flattens associated data into a separate root-level collection to avoid deep nesting and reduce payload duplication.
- Response Formatters - Adds pagination metadata and authorization-based filtering to Rails controller responses.
- API Response Optimizations - Reduces server load by caching serialized JSON data and monitoring conversion metrics.
- Serialized Output Caching - Stores serialized object results as JSON to reduce computation time for repeat requests.
- Fragment Caches - Provides fragment caching to store specific serialized object outputs and bypass redundant computation for repeat requests.
- Resource Serialization Formats - Processes collections of resources by applying specific serializers to each item in the group.
- Casing Transformers - Implements global and class-level formatting rules to convert attribute keys into specific casing styles.
- Object Serialization - Applies consistent serialization behavior to non-database plain Ruby objects for uniform API responses.
- Computed Attribute Derivation - Allows the definition of virtual attributes that are computed via custom logic during serialization.
- Associated Data Sideloading - Implements sideloading of associated records to simplify client-side parsing and reduce payload duplication.
- Association ID Embedding - Provides the ability to embed only identifiers for associated objects to minimize response size.
- Document Structure Control - Controls the final structure of the JSON response, allowing for flat lists or specific specification layouts.
