juhaku/utoipa

Features

• Documentation Macros - Uses procedural macros to describe API paths, expected parameters, and possible responses directly in the code.
• OpenAPI Specification Generators - Constructs complete OpenAPI specification documents including servers, endpoints, and security requirements from Rust code.
• REST API Specifications - Generates interactive web interfaces and OpenAPI specifications to describe endpoints, request bodies, and response formats.
• Code-to-Schema Generation - Analyzes Rust source code and attributes to generate external OpenAPI data validation schemas.
• API Schema Mapping - Maps complex data structures, including arrays and objects, to schemas for API request and response bodies.
• Trait-Based - Converts complex Rust data structures into OpenAPI schema objects through a shared interface for type conversion.
• Automatic Specification Generators - Automatically derives OpenAPI specifications and schemas from source code using procedural macros and traits.
• API Specification Analysis - Builds machine-readable definitions of endpoints and security requirements using automated code analysis.
• OpenAPI Specification Generators - Generates YAML and JSON OpenAPI specifications from Rust code using procedural macros and traits.
• Metadata Extraction Macros - Utilizes procedural macros to analyze Rust types and attributes at compile time to generate API definitions.
• Request Parameter Parsing - Parses path, query, and request body parameters from web framework attributes using type annotations.
• Response Specifications - Defines expected endpoint outputs, including HTTP status codes and associated data structures.
• Type-Safe API Schemas - Maps complex Rust data structures, including generics and polymorphism, into compliant OpenAPI schema objects.
• API Documentation Tools - Provides a complete toolset for creating machine-readable API definitions by mapping Rust types to OpenAPI schemas.
• API Path Mappings - Connects functions to specific HTTP methods and endpoint paths to define request routing in the specification.
• Framework Macro Integrations - Extracts paths, methods, and parameter types directly from web framework-specific macros and handler arguments.
• Input Parameter Specifications - Lists path, query, and header variables an endpoint accepts to automate input requirement specifications.
• Request Body Documentation - Describes the structure and requirements of incoming request bodies to ensure correct documentation of inputs.
• Request Payload Specifications - Defines the expected input payload using data types and schemas to ensure correct API request documentation.
• Response Schema Mappings - Maps Rust data types to OpenAPI response objects by associating status codes and schemas with specific structures.
• Documentation Schemas - Maps Rust data structures to OpenAPI schema objects to document request and response formats.
• Rust-to-OpenAPI Schema Mappers - Converts Rust structs and enums into OpenAPI compliant schemas with support for generics and polymorphism.
• Handler Metadata Extraction - Extracts path parameters, query parameters, and request bodies directly from route handlers for documentation.
• Request-Response Type Mapping - Converts Rust structs and enums into schemas and response objects to document API inputs and outputs.
• OpenAPI Format Mapping - Converts specialized types, such as dates and UUIDs, into compliant OpenAPI schema formats.
• Interactive Documentation Interfaces - Hosts an interactive web interface that renders OpenAPI specifications for exploring and testing endpoints.
• Specification Type Translations - Translates internal Rust data types into standard OpenAPI formats for consistent external parameter documentation.
• Attribute-Based Mappings - Synchronizes renaming and tagging settings from serialization attributes directly into the generated OpenAPI specification.
• API Authentication Schemes - Specifies authentication methods such as API keys and OAuth2 flows to secure documented endpoints.
• API Authentication Schemes - Defines authentication schemes such as OAuth2 and API keys within the service specification.
• Polymorphic Schema Mapping - Creates composite object schemas using selection patterns to handle endpoints returning multiple different types.
• Recursive Type Resolution - Prevents infinite loops during schema generation by tracking type references and marking termination points for cyclic structures.
• Framework-Specific Integrations - Maps framework-specific route metadata and handler arguments into a standardized representation for specification generation.
• Nested API Definitions - Supports organizing large API specifications by nesting smaller, modular API definitions within a root instance.
• Recursive Data Schemas - Prevents infinite loops in the schema tree by marking specific fields to stop recursion during type referencing.
• Reusable Response Components - Generates reusable response components from data structures by mapping types and comments to the specification.
• API Documentation - Hosts a web interface allowing users to interactively explore and test API endpoints through a browser.
• Declarative Serialization Mappings - Synchronizes field renaming and tagging from serialization attributes to ensure the specification matches the actual JSON output.
• Response Format Descriptions - Provides detailed descriptions of HTTP status codes and data structures returned by API endpoints to inform clients.
• Generic Type Support - Creates schemas for generic types by ensuring all parameters implement the required schema traits.
• Multi-Response Modeling - Defines a single type to represent and document various possible HTTP responses for a single API operation.
• Struct-to-Parameter Mappings - Generates path and query parameter definitions directly from Rust structs using documentation comments.
• Web Framework Integrations - Integrates with Rust web frameworks to extract route metadata and parameter types directly from handlers.

Star history