feat: ✨ add more API methods; update example; fix ActivityParty struc…

…t; refactor HttpClient

examples/simple_with_logging.cpp

@@ -1,5 +1,5 @@
-#include "ekizu/embed_builder.hpp"
 #include <dotenv/dotenv.h>
+#include <ekizu/embed_builder.hpp>
 #include <ekizu/http_client.hpp>
 #include <ekizu/shard.hpp>
 #include <nlohmann/json.hpp>
@@ -104,7 +104,7 @@ std::function<void(Event)> handle_event(HttpClient &http)
 								{ "https://avatars.githubusercontent.com/u/59069386?v=4" })
 							.build();
 
-					const auto res =
+					auto res =
 						http.create_message(
 							    msg.channel_id)
 							.content(fmt::format(
@@ -120,10 +120,24 @@ std::function<void(Event)> handle_event(HttpClient &http)
 							.send();
 
 					if (!res) {
-						fmt::println(
+						logger->error(
 							"Failed to send message: {}",
 							res.error().message());
 					}
+
+					if (msg.content == "delete me") {
+						res = http.delete_message(
+								  msg.channel_id,
+								  msg.id)
+							      .send();
+
+						if (!res) {
+							logger->error(
+								"Failed to delete message: {}",
+								res.error()
+									.message());
+						}
+					}
 				},
 				[&logger](const Log &log) {
 					logger->debug("Log: {}", log.message);

include/ekizu/http_client.hpp

@@ -2,21 +2,30 @@
 #define EKIZU_HTTP_CLIENT_HPP
 
 #include <ekizu/rate_limiter.hpp>
+#include <ekizu/request/bulk_delete_messages.hpp>
 #include <ekizu/request/create_message.hpp>
+#include <ekizu/request/delete_message.hpp>
 
 namespace ekizu
 {
 struct HttpClient {
 	explicit HttpClient(std::string_view token);
 
 	[[nodiscard]] CreateMessage create_message(Snowflake channel_id);
+	[[nodiscard]] DeleteMessage delete_message(Snowflake channel_id,
+						   Snowflake message_id);
+	[[nodiscard]] BulkDeleteMessages
+	bulk_delete_messages(Snowflake channel_id,
+			     const std::vector<Snowflake> &message_ids);
 
     private:
 	/// Function which sends an HTTP request. This is wrapped around a ratelimiter and passed around to other structs which need the functionality.
 	[[nodiscard]] Result<net::HttpResponse> send(net::HttpRequest req);
 
 	std::optional<net::HttpConnection> m_http;
 	RateLimiter m_rate_limiter;
+	std::function<Result<net::HttpResponse>(net::HttpRequest)>
+		m_rate_limiter_make_request;
 	std::optional<std::string> m_token;
 };
 } // namespace ekizu

include/ekizu/presence.hpp

@@ -66,9 +66,9 @@ EKIZU_EXPORT void from_json(const nlohmann::json &j, ActivityEmoji &e);
 
 struct ActivityParty {
 	/// Party id
-	std::optional<Snowflake> id;
+	std::optional<std::string> id;
 	/// Party size
-	std::optional<uint32_t> size;
+	std::optional<std::array<uint64_t, 2> > size;
 };
 
 EKIZU_EXPORT void to_json(nlohmann::json &j, const ActivityParty &p);

include/ekizu/request/bulk_delete_messages.hpp

@@ -0,0 +1,28 @@
+#ifndef EKIZU_REQUEST_BULK_DELETE_MESSAGES_HPP
+#define EKIZU_REQUEST_BULK_DELETE_MESSAGES_HPP
+
+#include <ekizu/snowflake.hpp>
+#include <net/http.hpp>
+
+namespace ekizu
+{
+struct BulkDeleteMessages {
+	BulkDeleteMessages(
+		const std::function<Result<net::HttpResponse>(net::HttpRequest)>
+			&make_request,
+		Snowflake channel_id,
+		const std::vector<Snowflake> &message_ids);
+
+	operator net::HttpRequest() const;
+
+	[[nodiscard]] Result<net::HttpResponse> send();
+
+    private:
+	Snowflake m_channel_id;
+	std::vector<Snowflake> m_message_ids;
+	std::function<Result<net::HttpResponse>(net::HttpRequest)>
+		m_make_request;
+};
+} // namespace ekizu
+
+#endif // EKIZU_REQUEST_BULK_DELETE_MESSAGES_HPP

include/ekizu/request/create_message.hpp

@@ -35,8 +35,10 @@ EKIZU_EXPORT void to_json(nlohmann::json &j, const CreateMessageFields &f);
 EKIZU_EXPORT void from_json(const nlohmann::json &j, CreateMessageFields &f);
 
 struct CreateMessage {
-	CreateMessage(std::function<Result<net::HttpResponse>(net::HttpRequest)>,
-		      Snowflake channel_id);
+	CreateMessage(
+		const std::function<Result<net::HttpResponse>(net::HttpRequest)>
+			&make_request,
+		Snowflake channel_id);
 
 	operator net::HttpRequest() const;
 

include/ekizu/request/delete_message.hpp

@@ -0,0 +1,27 @@
+#ifndef EKIZU_REQUEST_DELETE_MESSAGE_HPP
+#define EKIZU_REQUEST_DELETE_MESSAGE_HPP
+
+#include <ekizu/snowflake.hpp>
+#include <net/http.hpp>
+
+namespace ekizu
+{
+struct DeleteMessage {
+	DeleteMessage(
+		const std::function<Result<net::HttpResponse>(net::HttpRequest)>
+			&make_request,
+		Snowflake channel_id, Snowflake message_id);
+
+	operator net::HttpRequest() const;
+
+	[[nodiscard]] Result<net::HttpResponse> send();
+
+    private:
+	Snowflake m_channel_id;
+	Snowflake m_message_id;
+	std::function<Result<net::HttpResponse>(net::HttpRequest)>
+		m_make_request;
+};
+} // namespace ekizu
+
+#endif // EKIZU_REQUEST_DELETE_MESSAGE_HPP

src/http_client.cpp

@@ -12,17 +12,31 @@ HttpClient::HttpClient(std::string_view token)
 	: m_rate_limiter{ [this](net::HttpRequest req) {
 		return send(std::move(req));
 	} }
+	, m_rate_limiter_make_request{ [this](net::HttpRequest req) {
+		return m_rate_limiter.send({ std::move(req) });
+	} }
 	, m_token{ token }
 {
 }
 
 CreateMessage HttpClient::create_message(Snowflake channel_id)
 {
-	return CreateMessage{ [this](net::HttpRequest req) {
-				     return m_rate_limiter.send(
-					     { std::move(req) });
-			     },
-			      channel_id };
+	return CreateMessage{ m_rate_limiter_make_request, channel_id };
+}
+
+DeleteMessage HttpClient::delete_message(Snowflake channel_id,
+					 Snowflake message_id)
+{
+	return DeleteMessage{ m_rate_limiter_make_request, channel_id,
+			      message_id };
+}
+
+BulkDeleteMessages
+HttpClient::bulk_delete_messages(Snowflake channel_id,
+				 const std::vector<Snowflake> &message_ids)
+{
+	return BulkDeleteMessages{ m_rate_limiter_make_request, channel_id,
+				   message_ids };
 }
 
 Result<net::HttpResponse> HttpClient::send(net::HttpRequest req)

src/request/bulk_delete_messages.cpp

@@ -0,0 +1,35 @@
+#include <ekizu/request/bulk_delete_messages.hpp>
+#include <nlohmann/json.hpp>
+
+namespace ekizu
+{
+BulkDeleteMessages::BulkDeleteMessages(
+	const std::function<Result<net::HttpResponse>(net::HttpRequest)>
+		&make_request,
+	Snowflake channel_id, const std::vector<Snowflake> &message_ids)
+	: m_channel_id{ channel_id }
+	, m_message_ids{ message_ids }
+	, m_make_request{ make_request }
+{
+}
+
+BulkDeleteMessages::operator net::HttpRequest() const
+{
+	return {
+		net::HttpMethod::Post,
+		fmt::format("/channels/{}/messages/bulk-delete", m_channel_id),
+		nlohmann::json{ { "messages", m_message_ids } }.dump(),
+		{},
+	};
+}
+
+Result<net::HttpResponse> BulkDeleteMessages::send()
+{
+	if (!m_make_request) {
+		return tl::make_unexpected(std::make_error_code(
+			std::errc::operation_not_permitted));
+	}
+
+	return m_make_request(*this);
+}
+} // namespace ekizu

src/request/create_message.cpp

@@ -37,10 +37,11 @@ void from_json(const nlohmann::json &j, CreateMessageFields &f)
 }
 
 CreateMessage::CreateMessage(
-	std::function<Result<net::HttpResponse>(net::HttpRequest)> make_request,
+	const std::function<Result<net::HttpResponse>(net::HttpRequest)>
+		&make_request,
 	Snowflake channel_id)
 	: m_channel_id{ channel_id }
-	, m_make_request{ std::move(make_request) }
+	, m_make_request{ make_request }
 {
 }
 

src/request/delete_message.cpp

@@ -0,0 +1,35 @@
+#include <ekizu/request/delete_message.hpp>
+
+namespace ekizu
+{
+DeleteMessage::DeleteMessage(
+	const std::function<Result<net::HttpResponse>(net::HttpRequest)>
+		&make_request,
+	Snowflake channel_id, Snowflake message_id)
+	: m_channel_id{ channel_id }
+	, m_message_id{ message_id }
+	, m_make_request{ make_request }
+{
+}
+
+DeleteMessage::operator net::HttpRequest() const
+{
+	return {
+		net::HttpMethod::Delete,
+		fmt::format("/channels/{}/messages/{}", m_channel_id,
+			    m_message_id),
+		{},
+		{},
+	};
+}
+
+Result<net::HttpResponse> DeleteMessage::send()
+{
+	if (!m_make_request) {
+		return tl::make_unexpected(std::make_error_code(
+			std::errc::operation_not_permitted));
+	}
+
+	return m_make_request(*this);
+}
+} // namespace ekizu