hey-api/openapi-ts
Openapi Ts
openapi-ts is a tool and orchestrator used to convert OpenAPI specifications into type-safe TypeScript SDKs and HTTP client implementations. It automatically generates typed interfaces and request functions from API definitions to ensure consistency between the server and the client.
The project employs a transport-agnostic client interface, decoupling high-level API calls from the underlying network library. It uses a plugin-based generation pipeline and a custom plugin architecture to allow for the customization of output types and validation schemas.
The system provides capabilities for network layer abstraction and traffic interception through middleware. It also includes support for request cancellation to manage network lifecycles and maps JSON schema definitions to static TypeScript types.
Features
- Type-Safe Client Generators - Automatically generates type-safe TypeScript SDKs and interfaces from OpenAPI specifications.
- OpenAPI Client SDK Generators - Produces compatible client code and schema enums based on local or remote OpenAPI specifications.
- API Specification Importers - Supports loading OpenAPI definitions from local files, remote URLs, or registries to drive client generation.
- Schema-Driven Code Generators - Transforms OpenAPI specifications into TypeScript type definitions and client interfaces via an automated build process.
- Pluggable Transport Layers - Decouples high-level API calls from network libraries using a swappable transport layer implementation.
- HTTP Abstraction Layers - Encapsulates low-level network objects to provide a consistent high-level API across different runtimes.
- API Client Generators - Converts API definitions into typed interfaces and request functions to ensure server-client consistency.
- TypeScript Type Synthesis - Automatically synthesizes static TypeScript interfaces from JSON schema definitions.
- HTTP Request Clients - Automates the creation of SDKs from API schemas to replace manual writing of request functions.
- Type-Safe API Integrations - Synchronizes data schemas between client and server using OpenAPI specifications to ensure full TypeScript support.
- Transport Abstractions - Provides a transport-agnostic client interface that decouples API calls from the underlying network library.
- Runtime Compatibility Layers - Produces client code compatible with various networking libraries and web frameworks for cross-environment execution.
- Middleware-Based Request Pipelines - Implements a modular chain of pluggable components to intercept and process network requests and responses.
- HTTP Transport Configurations - Allows customizing the network layer by selecting specific libraries or native browser interfaces for different environments.
- Request Cancellations - Implements a cancellable promise pattern to abort active network requests and save bandwidth.
- Plugin Extenders - Enables extending functionality through custom plugins that interact with internal system interfaces.
- Request Middleware - Sets up interceptors to handle cross-cutting concerns like authentication headers and activity logging.
- Generation Pipeline Customization - Provides control over generated output by composing plugins to include specific types and validation schemas.
- Plugin-Based Architectures - Uses a plugin-based architecture to allow customization of output types and validation schemas during generation.
- Request Interception Middleware - Provides middleware pipeline handlers to intercept and modify outgoing requests and incoming responses.
