spec-first/connexion

Features

• Runtime Schema Enforcement - Ensures incoming requests and outgoing responses strictly adhere to a predefined OpenAPI schema to guarantee contract compliance.
• Spec-First API Frameworks - Provides a full framework to build an API by mapping operation identifiers to handlers while managing routing, security, and parsing.
• API Payload Serializers - Converts internal language objects into the format specified by the API documentation for the client.
• Automatic Route Registration - Links API endpoints to handler functions automatically using a specification to eliminate manual route decorators.
• Controller Response Serializers - Automatically converts controller return values into network responses that match the specified OpenAPI schemas and content types.
• Request Parameter Parsing - Extracts values from the request and passes them as arguments to handler functions to remove manual parsing.
• API Authentication - Manages programmatic access to services by enforcing identity verification defined in the API specification.
• Security Requirement Mappings - Verifies that incoming requests meet the specific security schemes and scopes defined in the OpenAPI document.
• Automated API Documentation - Generates interactive API documentation that stays synchronized with the implementation and the OpenAPI specification.
• Contract-First API Frameworks - Implements a design workflow where the API contract drives the generation of routing and validation logic.
• Mock Server Generators - Simulates API behavior by serving example responses generated directly from the specification schemas without a backend implementation.
• Request Validation - Verifies that incoming headers, query parameters, and request bodies adhere to the constraints defined in the API specification.
• API Simulation and Mocking - Simulates API behavior and serves example responses from a specification to enable frontend development before backend implementation.
• Function-to-URL Mappings - Links API operations to functions or class methods using operation identifiers or automated resolution.
• API Mocking Servers - Serves example responses based on specification schemas to simulate API behavior without a backend implementation.
• API Parameter Validation - Checks incoming headers, parameters, and bodies against a specification to ensure requirements are met.
• API Routing - Automatically maps incoming requests to handler functions based on a predefined OpenAPI specification.
• Automatic Parameter Injection - Automatically parses request parameters and injects them as typed arguments into handler functions based on the API specification.
• Request Body Validations - Defines pluggable validation logic based on content types to verify that request bodies match expected formats.
• Schema-Based Request and Response Validation - Ensures both incoming requests and outgoing responses strictly comply with the API contract schemas.
• Interactive API Documentation UIs - Includes a web interface that lets users visualize and interact with the API based on the specification.
• Operation ID Mappings - Links API endpoints to Python code by resolving operation identifiers from the specification to specific handler functions.
• Parameter Injections - Parses parameters from the request and injects them directly into handler functions.
• Request Validation Middleware - Provides middleware that verifies incoming headers, parameters, and bodies against an OpenAPI schema before reaching the handler.
• Response Serialization - Converts language types into network responses automatically based on the specified content types.
• API Response Validation - Verifies that outgoing response bodies and headers adhere to the defined OpenAPI specification before delivery.
• OpenAPI Frameworks - Integrates OpenAPI specification and JSON Schema validation directly into the Python web development workflow.
• Specification-Driven Routing - Maps incoming network requests to handler functions by resolving operation identifiers and paths defined in an OpenAPI document.
• Specification-to-Function Parameter Mappings - Parses and casts path, query, and body parameters from a specification into function arguments.
• Typed Path Parameter Decoders - Captures variable URL segments and converts them into typed arguments based on the specification definitions.
• Security Middleware - Enforces security policies and verifies authentication credentials via middleware based on the API contract.
• Exception Mapping - Maps HTTP status codes to custom handler functions that process exceptions into structured responses.
• Problem Details Formatting - Formats API error responses using the RFC 7807 Problem Details standard for machine-readable consistency.
• Request Context Injection - Passes metadata like the base path, operation ID, and authentication details into the view function.
• Content-Type Validators - Defines pluggable validation logic for request bodies and responses based on specific content types.
• Operation Metadata - Provides access to operation details for the current request, including defined schemas and security requirements.
• Specification-Based Mocking - Automatically generates mock responses based on API specification files via a command line interface.
• Simulated Request Testing - Provides a test client to simulate HTTP requests against the application without requiring a live network server.
• Exception Response Mapping - Registers custom handlers to convert exception classes or HTTP status codes into formatted error responses.
• RFC 7807 Implementations - Translates application exceptions into machine-readable JSON error responses following the RFC 7807 standard.
• HTTP Problem Translation - Translates exceptions into standardized HTTP problem responses to provide consistent error reporting to clients.
• UI Configurations - Customizes the visual appearance and behavioral settings of the integrated interactive API documentation interface.
• Spec-Driven Server Bootstrapping - Launches a functional web server directly from a specification file to verify API structure.
• REST Semantic Resolutions - Infers mappings between API paths and handler functions using REST semantics to reduce the need for explicit identifiers.
• Web APIs - A spec-first framework that automatically handles requests based on OpenAPI.

Historique des stars