Projects sharing features with Flasgger

Elysia is a high-performance TypeScript web framework designed for building type-safe backend services. It provides a modular, plugin-based architecture that allows developers to compose server logic, middleware, and validation schemas into scalable application instances. By leveraging native web standards, the framework ensures portability across diverse JavaScript runtimes, including Node.js, Deno, and various edge computing environments. The framework distinguishes itself through its focus on end-to-end type safety, automatically synchronizing request and response definitions between the s

This project is an automated documentation generator that synchronizes API reference materials with actual code behavior. By capturing live HTTP request and response data during the execution of existing test suites, it ensures that documentation remains accurate and consistent with the underlying application. The tool distinguishes itself by integrating directly into the test runner lifecycle, allowing developers to define API specifications and metadata within their test blocks. This approach enables a test-driven documentation workflow where API behavior is recorded and mapped to structure

Salvo is a comprehensive Rust web framework for building asynchronous HTTP servers and web applications. It features a hierarchical web router that uses a tree-based structure to map requests to handlers and an asynchronous middleware pipeline based on the onion model for request and response pre- and post-processing. The framework is distinguished by its native support for modern network protocols, including a QUIC-based HTTP/3 implementation alongside HTTP/1 and HTTP/2. It includes an integrated OpenAPI documentation generator that extracts schemas directly from handler signatures to produc

go-swagger is a toolkit for working with Swagger/OpenAPI 2.0 specifications in Go. It generates server, client, and CLI code from a specification document, and can also produce a specification by scanning annotated Go source code. The project includes a static validation engine that checks documents against the schema and project-specific rules, and a specification transformation pipeline that resolves, flattens, and merges documents. The toolkit generates both client and server code from the same specification, ensuring consistency in request and response handling. It also produces a command

This project is a comprehensive library of reference implementations and patterns for building web applications using the Go Fiber framework. It provides curated templates and implementation guides for creating REST APIs, web servers, and structured backend services. The repository serves as a practical resource for applying architectural patterns, including Clean and Hexagonal architectures, as well as port-and-adapter decoupling. It offers detailed examples for integrating common web features such as OAuth2 authentication, JWT verification, WebSockets for real-time communication, and server

swagger-core is a set of libraries for parsing, generating, and serializing OpenAPI specifications to automate REST API documentation. It provides tools to read, validate, and transform JSON or YAML specifications into programmable objects, as well as a generator that scans source code and annotations to create formal technical descriptions of an API. The project enables bi-directional specification serialization, allowing in-memory API definitions to be converted between native language objects and structured files. It uses a plugin-based scanning mechanism and annotation-driven generation t

Valibot is a modular, type-safe schema library for validating and parsing structural data in TypeScript environments.

async-validator is a JavaScript schema validation library and asynchronous data validation engine. It verifies complex object structures and nested arrays by applying recursive rules and non-blocking, promise-based execution to ensure data integrity. The library functions as both an object constraint validator and a data transformation pipeline. It allows for the sanitization, coercion, and formatting of input values through a sequence of functions that run before and after the primary validation process. The engine covers a range of capabilities including recursive nested validation, the en

Typia is a compile-time code generator that transforms TypeScript type annotations into runtime validation, serialization, and schema functions without requiring decorators or separate schema files. It generates optimized validation and serialization code during TypeScript compilation, producing dedicated functions for each type that eliminate runtime schema objects for faster execution. The project extends this core capability into several integrated areas. It generates fully typed client SDKs from NestJS controller source code, keeping server and client types synchronized automatically. It

Huma is an OpenAPI REST framework for Go designed for building HTTP services with automatic OpenAPI 3.1 specification generation and JSON Schema validation. It serves as a toolkit for developing REST and RPC APIs with typed inputs and outputs, deriving interactive documentation directly from the source code. The framework distinguishes itself by automating the synchronization between implementation and documentation. It uses a content-negotiation engine to manage multiple serialization formats via client headers and employs a JSON Schema input validator to automatically verify request paramet

Swag is a documentation tool for Go that generates standardized API specification files by parsing declarative annotations within source code. It functions by analyzing source files to extract metadata from comments and function signatures, transforming them into machine-readable formats such as JSON or YAML. This process ensures that technical documentation remains synchronized with the underlying code structure throughout the development lifecycle. The tool distinguishes itself through its ability to perform static source code parsing and type-system reflection, which allows it to map compl

Swagger Codegen is a template-driven engine and multi-language toolkit used to generate API client SDKs, server stubs, and human-readable documentation from OpenAPI specifications. It translates these specifications into functional libraries and boilerplate routing code across various target programming languages. The tool utilizes a pluggable generator module system and an integrated template engine, allowing for the customization of generated source code and the creation of new language-specific generators. It supports flexible specification sourcing via local files, remote HTTP endpoints,

This project is a web-based documentation viewer and interactive console designed to render API specifications into browser-based interfaces. It provides a framework for exploring endpoints, managing authorization flows, and executing live test requests directly against defined services. By parsing specification files into structured data models, the tool generates dynamic interfaces that allow developers to interact with API definitions in real time. The console is built as a library of reusable web components, enabling developers to embed documentation viewers into existing web applications

utoipa is a Rust API documentation tool used to generate machine-readable OpenAPI specifications. It functions as a specification generator and schema mapper that converts Rust structs and enums into compliant OpenAPI schemas. The project distinguishes itself by using procedural macros and traits to automate metadata extraction from code. It supports complex data modeling, including generics, polymorphism, and recursive type resolution, while synchronizing field renaming and tagging from serialization attributes. It also enables the composition of modular specifications, allowing multiple sma

swagger-php is an OpenAPI specification generator and PHP API documentation library. It scans PHP source code attributes and annotations to produce standardized specification files and interactive API references. The tool functions as a schema inference engine that derives data types and schemas from native PHP type hints and generic blocks. It uses reflection-based static analysis to extract metadata without executing application logic and supports recursive schema inheritance to merge definitions from parent classes and interfaces. The project includes a command-line utility for exporting

Swagger-jsdoc is a documentation utility that automates the creation of standardized interface specifications for web services and RESTful endpoints. It functions as a documentation builder that extracts metadata directly from source code comments and configuration files to maintain synchronized interface definitions alongside application logic. The tool parses code structures and merges disparate configuration files to produce machine-readable documentation that adheres to industry standards. By utilizing rule-based validation, it ensures that the generated output complies with formal struct

tsoa is a TypeScript API framework that synchronizes server routing, request validation, and API documentation through the static analysis of typed controllers. It functions as a Node server route generator and an OpenAPI REST API generator, converting TypeScript models and controllers into routing configurations and API specifications. The project differentiates itself by using static type analysis to extract metadata from source code without executing it. This metadata is used to synthesize OpenAPI specifications and generate JSON schemas for structural validation of request payloads. The

This project provides a comprehensive architectural framework and set of standardized patterns for building, securing, and scaling production-ready Node.js applications. It serves as a foundational guide for establishing consistent development workflows, operational observability, and reliable service integration across distributed software systems. The framework distinguishes itself by emphasizing a schema-first approach to API development, ensuring that interface definitions drive the creation of server stubs, client libraries, and type definitions. It promotes a cloud-native posture by int

Springfox is a Java library that automatically generates OpenAPI-compliant documentation for Spring-based REST services. It scans Spring controller annotations and model classes at runtime to produce machine-readable API specifications, and bootstraps an interactive Swagger UI interface on application startup for browsing and testing documented endpoints. The project provides a migration path from Swagger 2 to OpenAPI 3, replacing legacy annotations and dependencies with OpenAPI 3 equivalents through a starter dependency and configuration change. It integrates with Spring's application contex

This project is a REST API framework for NestJS designed to automate the creation of boilerplate-free CRUD endpoints and resource management. It functions as an automated CRUD generator that produces controllers and services for standard database operations, accelerating the development of RESTful APIs. The toolkit includes a REST query parser that translates complex URL parameters into structured database filters, pagination, and sorting rules. It also operates as an API response serializer to control the exposure of entity fields and manage nested relations within JSON responses. For extend

NSwag is an OpenAPI toolchain for .NET that provides a suite of generators for converting OpenAPI specifications and JSON schemas into clients, server stubs, and structured documentation. It enables the creation of type-safe client libraries and data transfer objects, as well as the generation of OpenAPI specifications by analyzing .NET controllers. The project supports contract-first API development by generating server controller stubs from specifications and offers dedicated TypeScript API integration to ensure type safety in frontend applications. It also provides tools for hosting intera

springdoc-openapi is a library and toolset that analyzes Spring applications at runtime to produce machine-readable OpenAPI specifications in JSON and YAML formats. It serves as an integrator that extracts API metadata from Java source code and annotations to automate documentation for Spring-based services. The project distinguishes itself through its ability to aggregate API specifications from multiple remote microservices into a single unified interface and provide multiple visualization options, including Swagger UI and Scalar. It also offers a dedicated plugin for exporting documentatio

This project is a PHP-based framework designed for the automated development of standardized web services. It functions as a backend toolkit that maps internal data models to REST and GraphQL endpoints, providing built-in support for resource management, data serialization, and hypermedia-aware API operations. The framework distinguishes itself through a metadata-driven architecture that uses class-level attributes to automatically derive API schemas, validation rules, and documentation. By analyzing these definitions at runtime, it generates machine-readable specifications and interactive in

OpenAPI Generator CLI is a command-line utility designed to automate the creation of API artifacts from specification files. It functions as a tool for generating client libraries, server stubs, and documentation, enabling developers to produce consistent boilerplate code and reference materials across various programming languages. The project provides a wrapper that manages the lifecycle of a Java-based execution engine, which performs the actual code synthesis using logic-less templates. To ensure reproducible results and avoid dependency conflicts on the host system, the tool supports ver

AWS Powertools for Python is a utility framework designed for building production-ready Python functions on AWS Lambda. It provides a comprehensive suite of tools for observability, event parsing, routing, and idempotency management to streamline the development of serverless applications. The project distinguishes itself through specialized capabilities for event-driven architectures and AI agent orchestration. It enables the implementation of AI agents by exposing functions as tools via OpenAPI schemas and managing conversation states. Additionally, it features an idempotency library that p

Hug is a Python API framework used for building web services by mapping functions to HTTP endpoints via decorators and type annotations. It functions as a type-based validator that automatically converts and validates incoming request data based on Python type hints and serves as a WSGI-compliant web framework for deployment on production servers. The project is distinguished by its ability to automatically generate API specifications and user-facing documentation derived from function signatures. It further extends the utility of internal logic by exposing functions as terminal commands thro

APIStar is an OpenAPI framework providing a toolkit for building and verifying web APIs. It functions as an API schema validator, a traffic auditor, and a documentation generator to ensure compliance with API specifications and data types. The project converts OpenAPI and Swagger schemas into visual developer guides using customizable themes. It also implements a dynamic API client that adapts to defined schemas to send requests to remote servers. The framework includes capabilities for validating API schemas to identify structural mistakes and auditing incoming and outgoing web traffic agai