Added async/await interface for all HTTP methods

Author: kzhdev

CHANGELOG.md

@@ -1,5 +1,18 @@
+# [1.2.0] - 2025-01-18
+
+## New Features
+- **C++20 Coroutine Awaitable HTTP API**: Added modern async/await interface for all HTTP methods
+  - `asio::awaitable<Response> async_get(url, headers)` - Awaitable GET request
+  - `asio::awaitable<Response> async_post(url, data, headers)` - Awaitable POST request
+  - `asio::awaitable<Response> async_put(url, data, headers)` - Awaitable PUT request
+  - `asio::awaitable<Response> async_patch(url, data, headers)` - Awaitable PATCH request
+  - `asio::awaitable<Response> async_del(url, data, headers)` - Awaitable DELETE request
+  - Clean async/await syntax using `co_await` for sequential or parallel HTTP operations
+  - Uses caller's executor context (no service thread management required)
+  - Supports both HTTP and HTTPS protocols
+
 # [1.1.2] - 2025-11-13
-- Remove unnecessary slick_logger from slick_net link dependencies 
+- Remove unnecessary slick_logger from slick_net link dependencies
 - Update CMakeLists to link slick_logger with example executables
 
 # [1.1.1] - 2025-10-22

CMakeLists.txt

@@ -7,8 +7,10 @@ if (MSVC)
     endif()
 endif()
 
-set(BUILD_VERSION 1.1.2)
-project(slick_net VERSION ${BUILD_VERSION} LANGUAGES CXX)
+project(slick_net
+    VERSION 1.2.0
+    LANGUAGES CXX
+)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -139,7 +141,7 @@ if(CMAKE_BUILD_TYPE STREQUAL "Release")
 
     if (PROJECT_IS_TOP_LEVEL)
         add_custom_target(package_slick_net ALL
-            COMMAND ${CMAKE_COMMAND} -E tar "cfv" "${CMAKE_BINARY_DIR}/dist/slick_net_${BUILD_VERSION}.zip" --format=zip "include"
+            COMMAND ${CMAKE_COMMAND} -E tar "cfv" "${CMAKE_BINARY_DIR}/dist/slick_net_${PROJECT_VERSION}.zip" --format=zip "include"
             WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/dist"
             COMMENT "Creating zip archive"
         )

README.md

@@ -13,7 +13,7 @@ A high-performance C++ HTTP/WebSocket client library built on Boost.Beast with f
 - **HTTP Streaming**: Support for Server-Sent Events (SSE) and chunked response streaming
 - **Asynchronous WebSocket Client**: Built on Boost.Asio coroutines for high-performance async operations
 - **SSL/TLS Support**: Native support for secure `https://` and `wss://` connections
-- **Synchronous & Asynchronous APIs**: Both blocking and non-blocking HTTP operations
+- **Multiple Async APIs**: Synchronous, callback-based, and C++20 coroutine awaitable interfaces
 - **Cross-Platform**: Works on Windows, Linux, and macOS
 - **Header-Only**: Easy integration with minimal dependencies
 - **Callback-Based API**: Clean event-driven interface for connection lifecycle management
@@ -156,6 +156,7 @@ Run examples:
 ./examples/websocket_client_example
 ./examples/http_client_example
 ./examples/http_stream_client_example
+./examples/http_awaitable_client_example
 ```
 
 ## API Reference
@@ -171,7 +172,7 @@ Http::Response patch(std::string_view url, std::string_view data, std::vector<st
 Http::Response del(std::string_view url, std::string_view data, std::vector<std::pair<std::string, std::string>>&& headers = {});
 ```
 
-**Asynchronous Methods:**
+**Asynchronous Callback-Based Methods:**
 ```cpp
 void async_get(std::function<void(Response&&)> on_response, std::string_view url, std::vector<std::pair<std::string, std::string>>&& headers = {});
 void async_post(std::function<void(Response&&)> on_response, std::string_view url, std::string_view data, std::vector<std::pair<std::string, std::string>>&& headers = {});
@@ -180,6 +181,15 @@ void async_patch(std::function<void(Response&&)> on_response, std::string_view u
 void async_del(std::function<void(Response&&)> on_response, std::string_view url, std::string_view data, std::vector<std::pair<std::string, std::string>>&& headers = {});
 ```
 
+**Asynchronous Awaitable Methods (C++20 Coroutines):**
+```cpp
+asio::awaitable<Response> async_get(std::string_view url, std::vector<std::pair<std::string, std::string>>&& headers = {});
+asio::awaitable<Response> async_post(std::string_view url, std::string_view data, std::vector<std::pair<std::string, std::string>>&& headers = {});
+asio::awaitable<Response> async_put(std::string_view url, std::string_view data, std::vector<std::pair<std::string, std::string>>&& headers = {});
+asio::awaitable<Response> async_patch(std::string_view url, std::string_view data, std::vector<std::pair<std::string, std::string>>&& headers = {});
+asio::awaitable<Response> async_del(std::string_view url, std::string_view data = "", std::vector<std::pair<std::string, std::string>>&& headers = {});
+```
+
 **Response Structure:**
 ```cpp
 struct Response {
@@ -189,7 +199,7 @@ struct Response {
 };
 ```
 
-**Example Usage:**
+**Example Usage - Synchronous:**
 ```cpp
 #include <slick/net/http.h>
 
@@ -198,6 +208,11 @@ auto response = Http::get("https://api.example.com/data");
 if (response.is_ok()) {
     std::cout << response.result_text << std::endl;
 }
+```
+
+**Example Usage - Asynchronous Callback-Based:**
+```cpp
+#include <slick/net/http.h>
 
 // Asynchronous POST with JSON
 nlohmann::json data = {{"key", "value"}};
@@ -208,6 +223,41 @@ Http::async_post([](Http::Response&& rsp) {
 }, "https://api.example.com/resource", data.dump(), {{"Content-Type", "application/json"}});
 ```
 
+**Example Usage - Asynchronous Awaitable (C++20 Coroutines):**
+```cpp
+#include <slick/net/http.h>
+#include <boost/asio.hpp>
+
+asio::awaitable<void> fetch_data() {
+    // Awaitable GET - clean async/await syntax
+    auto response = co_await Http::async_get("https://api.example.com/data");
+    if (response.is_ok()) {
+        std::cout << "Response: " << response.result_text << std::endl;
+    }
+
+    // Sequential requests
+    nlohmann::json post_data = {{"key", "value"}};
+    auto post_response = co_await Http::async_post(
+        "https://api.example.com/resource",
+        post_data.dump(),
+        {{"Content-Type", "application/json"}}
+    );
+
+    if (post_response.is_ok()) {
+        std::cout << "Created: " << post_response.result_text << std::endl;
+    }
+}
+
+int main() {
+    asio::io_context ioc;
+
+    asio::co_spawn(ioc, fetch_data(), asio::detached);
+
+    ioc.run();
+    return 0;
+}
+```
+
 ### Websocket Class
 
 **Constructor:**

examples/CMakeLists.txt

@@ -25,4 +25,8 @@ target_link_libraries(http_client_example PRIVATE slick_net slick_logger nlohman
 
 add_executable(http_stream_client_example http_stream_client.cpp)
 target_include_directories(http_stream_client_example PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../include)
-target_link_libraries(http_stream_client_example PRIVATE slick_net slick_logger nlohmann_json::nlohmann_json)
+target_link_libraries(http_stream_client_example PRIVATE slick_net slick_logger nlohmann_json::nlohmann_json)
+
+add_executable(http_awaitable_client_example http_awaitable_client.cpp)
+target_include_directories(http_awaitable_client_example PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+target_link_libraries(http_awaitable_client_example PRIVATE slick_net slick_logger nlohmann_json::nlohmann_json)