envimate/httpmate

HttpMate is a Java framework for building HTTP and WebSocket servers that route requests through a configurable chain of processors. It provides integrations for deploying on AWS Lambda, Jetty, and Servlet containers, while supporting features like multipart form data, JWT authentication, and event-driven backends via a message bus. The system also includes an HTTP client API for making outbound requests and serializing responses using MapMate.

Introduces new integration endpoints for deploying HttpMate applications. This includes an AWS Lambda endpoint for handling API Gateway events, a standard Servlet endpoint for traditional web servers, and a WebSocket-aware servlet for handling WebSocket connections via Jetty. These components allow users to route HTTP requests and WebSocket frames through the HttpMate chain in their respective environments.

integrations/aws-lambda · high confidence

Users can now run HTTP endpoints using the Jetty server. This change introduces the Jetty integration, including the JettyEndpoint, JettyEndpointHandler, and PortStage interface, which allow the application to start an HTTP server on a specified port and handle incoming requests. Additionally, checkstyle and SpotBugs suppression files are added to manage static analysis warnings for the new code.

integrations/jetty, integrations/spark · high confidence

A new integration module for the Jetty server has been added, providing a way to start an HTTP server on a specified port that supports WebSockets. This includes a \JettyEndpointWithWebSocketsSupport\ class that configures a Jetty server with a servlet that handles both HTTP and WebSocket traffic, and a \PortStage\ interface to facilitate port configuration.

integrations/jetty-with-websockets/src/main · high confidence

Users can now integrate MapMate into their HTTP client configuration to handle serializing and deserializing request and response bodies. This new integration allows mapping HTTP content types to specific MapMate marshalling types (such as JSON, XML, and YAML) and configures the necessary modules to wire up the serializer and deserializer within the HTTPMate chain.

integrations/mapmate · high confidence

A new example for AWS Lambda has been added, featuring an integration layer that processes API Gateway proxy requests. The example includes a HelloUseCase that generates a greeting response with the current date, along with supporting request/response models and validation logic.

examples/aws-lambda · high confidence

A new BypassIssuer implementation has been introduced in the client module, providing a direct path for HTTP requests to bypass standard issuer logic. This change includes the BypassIssuer class, which handles request processing and response mapping, along with a supporting SynchronizationWrapper utility class to manage state during request handling.

integrations/client/src/main/java/com/envimate/httpmate/client/issuer/bypass · high confidence

A new Hello World example has been added to the repository, providing a complete, runnable application that demonstrates how to use HttpMate. This includes the main Application class, supporting data classes like Message and HelloMessageResponse, and a HelloWorldUseCase, along with the necessary checkstyle and spotbugs configuration files for the example.

examples/hello-world · high confidence

The integration now supports WebSocket connections, allowing for bidirectional communication. This change introduces a new processing pipeline that handles WebSocket establishment, message routing, and connection closure. Users can configure WebSocket endpoints by specifying path templates and defining which metadata fields (such as headers or query parameters) should be preserved during the connection lifecycle. The implementation includes processors for activating connections, handling incoming messages, and managing the registry of active sockets.

integrations/websocket · high confidence

Introduced the EventsBackChannelFactory to enable triggering backchannel events via a message bus, and added the SerializerAndDeserializer interface with a DelegatingDeserializerAndSerializer implementation to handle request/response mapping.

integrations/events/src/main/java/com/envimate/httpmate/events/backchannel, integrations/usecases/src/main/java/com/envimate/httpmate/usecases/serializing · high confidence

Added a new \examples/documentation\ module containing Java source files that serve as usage examples for the HTTPMate framework. These include \Documentation.java\ for basic routing, \AuthenticationExample.java\ and \BasicAuthExample.java\ for security configurations, \JwtExample.java\ and \CustomLoginExample.java\ for JWT and custom login flows, \ContentDispositionExample.java\ and \FileSystemExample.java\ for file downloads, \FormExample.java\ for handling form data, and \ReactExample.java\ for CORS and JSON handling. The set also includes supporting classes like \UserDatabase.java\ and \InMemoryUserDatabase.java\ for demonstration purposes.

examples/documentation · high confidence

The \httpmate/events\ package now includes a new \EventModule\ that configures chain processors for mapping HTTP requests to events, submitting them via a \MessageBus\, and extracting data from responses. This introduces new chain names (\MAP\_REQUEST\_TO\_EVENT\, \SUBMIT\_EVENT\, \MAP\_EVENT\_TO\_RESPONSE\, \EXTERNAL\_EVENT\) and interfaces (\RequestMapEnricher\, \ResponseMapExtractor\, \EventToResponseMapper\) that allow users to customize how request data is transformed into events and how event data is mapped back to HTTP responses.

integrations/events/src/main/java/com/envimate/httpmate/events · high confidence

The client now supports constructing multipart/form-data requests via the new Body, MultipartBodyCreator, and Part classes, enabling users to send complex form submissions with file streams and content types. Additionally, the websockets-usecases module introduces a WebSocketMessageSender and its configuration, allowing the application to serialize and send messages to a designated event type on a serialized message bus.

integrations/client/src/main/java/com/envimate/httpmate/client/body, integrations/websockets-usecases · high confidence

The HttpMate library now supports parsing multipart/form-data requests. This change introduces a new \MultipartModule\ that registers a chain rule to route requests with the \multipart/form-data\ content type to a new \MultipartProcessor\. This processor parses the request body into a \MultipartIteratorBody\, which provides an iterator over \MultipartPart\ objects representing form fields and file uploads. A corresponding \MultipartHandler\ interface and \MultipartRequest\ wrapper are also added to facilitate handling these requests.

integrations/multipart · high confidence

Added new classes in the websockets-events integration to handle WebSocket-specific event flows. This includes a processor (DetermineEventForWebSocketsProcessor) that identifies and maps incoming WebSocket messages to internal event types, alongside supporting classes (Conditions, EventMapping, IncomingEventMapping, WebSocketsExternalEventMapping) that define how events are filtered, mapped, and dispatched to active WebSocket connections.

integrations/websockets-events · high confidence

The core library now provides a builder-based API for configuring and running HTTP requests through a chain of processors. Users can construct an \HttpMate\ instance via \HttpMate.anHttpMate()\ and register handlers for specific HTTP methods and paths. The \CoreModule\ and \Configurators\ classes manage the internal state, while \ChainRegistry\ and \ChainExtender\ define the execution flow, allowing users to attach processors to named chains like \INIT\, \PROCESS\_HEADERS\, and \INVOKE\_HANDLER\. This change establishes the foundational structure for request handling, including exception mapping and response templating.

core/src/main · high confidence

Added a new HTTP client implementation in the \com.envimate.httpmate.client\ package, including classes for building requests (\HttpClientRequest\, \HttpClientRequestBuilder\), handling responses (\RawClientResponse\, \SimpleHttpResponseObject\), and managing client state (\HttpMateClient\, \HttpMateClientBuilder\). This provides a fluent builder pattern for constructing HTTP requests and mapping responses to target types.

integrations/client/src/main/java/com/envimate/httpmate/client · high confidence

Added a new real implementation of the HTTP client issuer, including connection management, endpoint handling, and request execution using Apache HttpClient. This provides the actual network communication layer for the HTTPMate client, supporting both standard and pooled connection strategies.

integrations/client/src/main/java/com/envimate/httpmate/client/issuer/real · high confidence

Added a new set of processors in the events integration module to handle the full lifecycle of an event: determining the event type, mapping requests to events, dispatching them via a message bus, handling external event mappings, serializing responses, and unwrapping dispatching exceptions. These components introduce new runtime behavior for event handling and error management within the processing chain.

integrations/events/src/main/java/com/envimate/httpmate/events/processors · high confidence

The \integrations/usecases\ module now introduces core components for handling use cases: an \EventFilter\ interface for filtering events, a \UseCaseConfigurators\ class to configure use-case instantiation, and a \UseCasesModule\ that registers serialized message bus handlers and maps use-case classes to event types. This provides the foundation for executing and configuring use cases within the HTTPMate integration layer.

integrations/usecases/src · high confidence

Added integration tests for the HTTP client; Added low-level HTTP test configuration; Added low-level handler implementations for testing; Added low-level integration tests for HTTPMate; Added low-level use case tests for exception handling; Added multipart request handling tests; Added test configuration and utility classes for HTTPMate; Added test coverage for HTTPMate integration and AWS Lambda test functions; Added test fixtures for low-level mapping scenarios; Added test infrastructure for AWS Lambda and client implementations; Added test infrastructure for HTTP interactions; Added test suite for Jetty WebSocket integration; Added test support classes for mapmate use cases; Added tests for low-level event triggering; Added unit tests for path template matching and parameter extraction.

The project's Maven build configuration has been updated across multiple modules, including core, integrations, and examples. Key changes include the addition of the \core\ module's \pom.xml\, updates to example modules (\aws-lambda\, \documentation\, \hello-world\), and various integration modules (\all\, \aws-lambda\, \client\, \events\, \jetty\, \mapmate\, \multipart\, \servlet\, \spark\, \usecases\, \websocket\, \websockets-events\, \websockets-usecases\). Specific dependency versions have been set or updated, such as \gson\ 2.8.6, \junit-jupiter\ for testing, \aws-lambda-java-events\ 2.2.7, \aws-lambda-java-core\ 1.2.0, \httpmime\ 4.5.10, \jetty\ 9.4.21.v20190926, \commons-fileupload\ 1.4, \spark-core\ 2.9.1, and \message-mate\ 1.0.10. The parent version is consistently set to 1.0.28.

(dependencies) · medium confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 66 → 64 (-1.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 99 (+0.3)
• Architecture 100 → 80 (-20.3)
• Maturity 49 → 49 (+0.0)
• Readiness 63 → 67 (+3.8)
• Security 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (6 lines × 2) (core/src/main/java/com/envimate/httpmate/http/headers/accept/MimeType.java)
• Duplicated block (6 lines × 2) (integrations/jetty/src/main/java/com/envimate/httpmate/jetty/JettyEndpointHandler.java)
• Duplicated block (7 lines × 2) (examples/documentation/src/main/java/com/envimate/httpmate/documentation/form/FormExample.java)
• Duplicated block (7 lines × 2) (integrations/jetty/src/main/java/com/envimate/httpmate/jetty/JettyEndpointHandler.java)
• Duplicated block (8 lines × 2) (core/src/main/java/com/envimate/httpmate/purejavaendpoint/PureJavaEndpointHandler.java)
• Duplicated block (8 lines × 2) (examples/documentation/src/main/java/com/envimate/httpmate/documentation/xx_usecases/calculation/CalculationExample.java)
• No exposed public API
• Scanner failed to run — not a clean result
• Test reliability not included
• The README begins with two Maven badges but does not state which version of HttpMate they refer to (the httpmate.version property), making the dependency bundle selection ambiguous for readers who want to reproduce it. (README.md)
• dormant codebase — no living knowledge left to concentrate

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (docs/README.md)
• Documentation: no project overview (docs/README.md)
• Documentation: no usage examples (README.md)
• Documentation: no usage examples (docs/01_QuickStart.md)
• Duplicated block (10 lines × 2) (core/src/main/java/com/envimate/httpmate/purejavaendpoint/PureJavaEndpointHandler.java)
• Duplicated block (36 lines × 2) (examples/documentation/src/main/java/com/envimate/httpmate/documentation/download/JavaResourceExample.java)
• Duplicated block (4–15 lines × 3) (examples/documentation/src/main/java/com/envimate/httpmate/documentation/authentication/CustomLoginExample.java)
• Duplicated block (5 lines × 2) (core/src/main/java/com/envimate/httpmate/http/headers/HeaderValueWithComment.java)
• Duplicated block (7 lines × 2) (core/src/main/java/com/envimate/httpmate/Configurators.java)
• Duplicated block (7 lines × 2) (integrations/jetty/src/main/java/com/envimate/httpmate/jetty/JettyEndpointHandler.java)
• Duplicated block (8 lines × 2) (examples/documentation/src/main/java/com/envimate/httpmate/documentation/xx_usecases/calculation/CalculationExample.java)
• Duplicated block (8 lines × 2) (integrations/client/src/main/java/com/envimate/httpmate/client/HttpClientRequestBuilder.java)
• Duplicated block (9 lines × 2) (integrations/jetty/src/main/java/com/envimate/httpmate/jetty/JettyEndpointHandler.java)
• No dependency advisory monitoring
• No direct assertions: aDirectoryLeadsToAnException (tests/testsuite/src/test/java/com/envimate/httpmate/tests/lowlevel/StaticFilesSpecs.java)
• No direct assertions: aFileCanBeServed (tests/testsuite/src/test/java/com/envimate/httpmate/tests/lowlevel/StaticFilesSpecs.java)
• No direct assertions: aFileSystemDirectoryCanBeServed (tests/testsuite/src/test/java/com/envimate/httpmate/tests/lowlevel/StaticFilesSpecs.java)
• No direct assertions: aFileSystemDirectoryCanBeServedWithAPrefix (tests/testsuite/src/test/java/com/envimate/httpmate/tests/lowlevel/StaticFilesSpecs.java)
• …and 152 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

envimate/httpmate was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.