middleapi/orpc

Features

• API Contract Definitions - Declares the type contract for a single API procedure, specifying input and output types without implementation details and serving as a single source of truth.
• Contract-First API Frameworks - An API design tool that starts with a shared contract and produces server implementation and client code from a single source of truth.
• Contract-First Type Safety - The entire API is defined as a contract first, and both server and client derive types from it, ensuring compile-time safety across the boundary.
• End-to-End Type Safety Frameworks - Guarantees end-to-end type safety for inputs, outputs, errors, and streaming across client-server boundary.
• Type-Safe Client Generators - Generates a type-safe client that mirrors the server contract with full auto-completion.
• Contract-First Specifications - Defines API contracts with shared schemas for end-to-end type safety between client and server.
• Type-Safe API Frameworks - A framework that defines typed API procedures with input/output validation and generates type-safe clients for end-to-end safety.
• Router Type Inference - Automatically derives the expected input and output types from a contract router for end-to-end type safety.
• OpenAPI Specification Generators - Exports API contracts as OpenAPI documents for documentation and third-party client generation.
• OpenAPI Router Exposure - Converts a router into a format that supports OpenAPI specification generation and request handling.
• Real-time Event Streams - Streams server-sent events or WebSocket messages using type-safe event iterators and pub-sub.
• Remote Procedure Calls - Invokes server procedures with identical syntax and type safety as local function calls.
• Type-Safe Remote Calls - Enables remote function calls over HTTP or WebSocket with full type inference and validation.
• Procedure Execution Interception - Hooks into procedure execution to run custom logic before, after, or around the handler.
• Remote Procedure Invocation Systems - Enables type-safe invocation of server procedures with full autocomplete from the client.
• Context Injectors - Injects request headers into the context so handlers can read them through a consistent interface.
• Type-Safe Real-Time RPC Platforms - A platform supporting WebSocket and SSE streaming for bidirectional, live data exchange with full type safety and reconnection support.
• Implicit Context Passing - Attaches runtime context to each procedure call to dynamically alter link behavior.
• Type-Based Contract Validation - Enforces contract types at compile time when building server-side logic.
• Contract Router Organizations - Groups multiple procedure contracts into a structured hierarchy for manageable API definition.
• Runtime Contract Validation - Checks input and output data against Zod, Valibot, or ArkType schemas defined in the contract.
• Contract-First Server Implementations - Implements server procedures from shared contracts with compile-time type enforcement.
• Schema-Driven Validations - Input and output data is validated at runtime using Zod, Valibot, or ArkType schemas declared in the contract.
• Server Action Integrations - Invokes type-safe procedures from server actions without additional configuration.
• In-Process SSR Data Fetching - Optimizes SSR by calling API handlers directly inside the server process, eliminating extra HTTP requests.
• API Procedure Routers - Provides structured routers for accessing typed API procedures by path.
• Type Inference - Extracts the input, output, and context types for every procedure in a router statically.
• Multi-Platform Exposures - Serves the defined API contract over HTTP using a server runtime, supporting multiple platforms.
• API Router Generators - Uses file structure or database schemas to produce fully-featured routers with validation and services.
• Context Injectors - Injects a headers object into the request context for modifying outbound HTTP response headers.
• Type-Safe Definitions - Converts a typed procedure into a server action callable from client components with full type safety and structured error handling.
• Server Action Hooks - Provides React hooks to call server actions from client components with basic invocation and optimistic updates.
• Frontend Query Library Hooks - Provides typed hooks for frontend query libraries like TanStack Query for type-safe data fetching.
• HTTP RPC Transports - Sends type-safe RPC requests over HTTP with end-to-end type safety.
• Query Library Configuration Generators - Generates type-safe options for TanStack Query hooks with support for advanced data patterns.
• Real-Time Communication - Handles WebSocket connections and SSE streaming for bidirectional, live data exchange.
• Remote Data Fetching Hooks - Generates type-safe query configurations that integrate with frontend data fetching hooks for reading API resources.
• Remote Procedure Calls - Provides type-safe remote procedure calls over HTTP with native data type preservation.
• Ordered Middleware Pipelines - An ordered middleware pipeline wraps procedure execution, allowing cross-cutting concerns such as authentication and logging to be inserted at specific points.
• OpenAPI Publishing - Automatically exposes the type-safe API contract as an OpenAPI-compliant REST interface.
• Type-Safe RPC Engines - An RPC server that exports OpenAPI specifications and can serve contracts over HTTP while preserving native type safety.
• In-Process API Call Bypasses - Bypasses HTTP requests during server-side rendering by using a local server-side client to reduce latency.
• Shared Router Client Reusers - Shares a router client across SSR requests to avoid redundant network calls and ensure consistent data types.
• Type-Safe API Clients - Provides recursive type inference from client objects for end-to-end type safety.
• Procedure Definitions - Encapsulates an API endpoint with input/output validation and middleware chaining for extensible communication.
• Type-Safe Mutation Configurations - Generates type-safe mutation configurations for writing API resources through frontend mutation hooks.
• Web Framework Integrations - Processes API requests within a web framework routing system, executing them with any supported handler type.
• Pipeline Hooks - Adds custom logic to server handlers by hooking into request processing stages from parsing to formatting.
• Fastify Integrations - Mounts any type-safe API handler on Fastify, leveraging its request parsing and plugin architecture.
• Environment-Aware Configurations - Configures RPC links to work seamlessly in both server and browser environments.
• Payload Serialization - Serializes JSON payloads for RPC with support for native data types and type safety.
• Client Middleware Extensions - Allows extending client requests and responses with middleware for authentication, logging, and retry.
• Security Plugin Packs - Applies ready-to-use plugins for CORS, CSRF protection, retry logic, and other cross-cutting concerns.
• Contract-Based File Uploads - Sends files alongside other data in a structured API call, supporting File and Blob objects.
• Isomorphic HTTP Clients - Configures RPC clients with separate settings for browser and server environments.
• JavaScript-Native RPC Protocols - Implements a custom RPC protocol that preserves JavaScript native types for type-safe communication.
• Per-Request Context Providers - Provides dynamic per-request context passing to customize procedure behavior.
• Token Streaming - Streams AI model tokens token by token for real-time display in client applications.
• In-Process Procedure Invocations - Invokes server procedures in-process for optimized server-side rendering.
• Server-Sent Events - Reads server-sent events by iterating over event iterators as async generators with lifecycle callbacks.
• Type-Safe Cross-Process Bridges - Multiple communication channels (HTTP, WebSocket, MessagePort, Electron) are abstracted behind a common bridge interface enabling type-safe cross-process messaging.
• WebSocket RPC Interfaces - Opens a persistent, low-latency WebSocket connection for bidirectional remote procedure calls.
• Durable Iterator Definitions - Defines a typed interface for durable iterator objects to ensure type safety between client and server.
• Router-to-Contract Converters - Converts a router definition into a contract object for sharing with clients, stripping lazy routes and minifying payloads.
• API Error Handling Patterns - Preserves error types across the client-server boundary for type-safe error handling.
• API Handler Mountings - Mounts a type-safe API handler inside Nuxt server routes using file-based routing.
• Monorepo Type Safety Structures - Maintains end-to-end type safety across projects by separating server packages and using TypeScript Project References.
• Validation Error Aggregators - Validates API inputs and returns structured error messages on failure.
• Type-Safe Context Injections - Supplies required dependencies explicitly or dynamically through middleware in a type-safe manner.
• Mock Implementations - Replaces actual procedure implementations with fake counterparts to isolate logic and simulate scenarios.
• Rate Limiting - Limits the number of requests a client can make within a time window and adds standard rate-limiting headers.
• Distributed Tracing Instrumentation - The library instruments client and server calls to propagate trace context and capture spans, enabling end-to-end observability without manual setup.
• Client-Side Input Validators - Validates user input on the client side using shared schemas before sending requests.
• Automatic Revalidation - Fetches data from a remote API with built-in caching and automatic revalidation to keep the UI updated.
• Type-Safe Query Error Detection - Ships built-in helpers for detecting defined error types within query and mutation results for precise handling.
• Resumable Event Streams - Persists events for configurable durations so clients resume missed events after reconnection.
• Durable Event Iterators - Streaming responses are delivered as durable iterators that support reconnection, hibernation, and event ID resumption for reliability.
• Express Integrations - Mounts typed API handlers as middleware on Express.js for request processing.
• Retry and Backoff Logic - Implements automatic retry with exponential backoff for failed client requests.
• Inter-Thread Communication - Enforces type-safe communication between worker threads by binding message port adapters to shared contract definitions.
• Global Middleware Registration - Adds a middleware step to every route in a router so cross-cutting concerns run once per request.
• Composable Permission Enforcers - Enforces permissions and authorization rules in a composable, type-safe manner across the application.
• Request-Response Interceptors - Provides hooks to inspect, transform, or abort RPC requests and responses.
• Response Validation - Validates server responses against the contract schema to ensure type safety.
• Route Handlers - Mounts a type-safe API handler in a route handler to expose the API through the application routing system.
• Solid Start Handler Mountings - Exposes a type-safe API handler as a route in Solid Start to process incoming requests.
• TanStack Query SSR Integrations - Combines server-side rendering with a data-fetching library for asynchronous data loading across server and client.
• Query Cache Hydration - Extends the serializer to include query caches, enabling seamless server-side rendering without refetching.
• RPC Over WebSocket - Makes remote procedure calls from client to server over the same persistent WebSocket used for event streaming.

Star history