RequestBuilder.h

// Copyright 2026 Stream.IO, Inc. All Rights Reserved.
 
#pragma once
#include "CoreMinimal.h"
#include "HttpResponse.h"
#include "Interfaces/IHttpRequest.h"
#include "QueryParameters.h"
#include "StreamJson.h"
 
class FHttpClient;
 
DECLARE_LOG_CATEGORY_EXTERN(LogHttpClient, Verbose, All);
 
template <class T>
struct TResponse
{
public:
    // Deserialize response if success
    explicit TResponse(const FHttpResponse& Response)
    {
        if (Response.IsSuccessful())
        {
            ResponseOrError.template Set<T>(Response.Json<T>());
        }
        else
        {
            ResponseOrError.template Set<FString>(TEXT("Error"));
        }
    }
 
    bool IsSuccessful() const
    {
        return ResponseOrError.template IsType<T>();
    }
 
    // Get a pointer to the held response, or nullptr if error
    const T* Get() const
    {
        return ResponseOrError.template TryGet<T>();
    }
 
    // Get a ref to the held response if you're SURE this isn't an error
    const T& GetRef() const
    {
        return ResponseOrError.template Get<T>();
    }
 
private:
    TVariant<T, FString> ResponseOrError;
};
 
class HTTPREQUESTS_API FRequestBuilder
{
public:
    FRequestBuilder() = delete;
 
    explicit FRequestBuilder(const TSharedRef<const FHttpClient>&, const FString& Verb, const FString& Url);
 
    FRequestBuilder& Header(const FQueryParameters& Headers);
 
    FRequestBuilder& Body(const FString& Text);
    FRequestBuilder& Query(const FQueryParameters& Query);
 
    FRequestBuilder& Multipart(const FString& FieldName, const FString& FileName, const TArray<uint8>& Content, const FString& ContentType = {});
 
    static TArray<uint8> BuildMultipartBody(
        const FString& Boundary,
        const FString& FieldName,
        const FString& FileName,
        const TArray<uint8>& Content,
        const FString& ContentType);
 
    template <class T>
    FRequestBuilder& Json(const T& Struct, ENamingConvention NamingConvention = ENamingConvention::SnakeCase);
    FRequestBuilder& EmptyJson();
 
    void Send(TFunction<void(const FHttpResponse&)> Callback);
 
    template <class T>
    void Send(TFunction<void(const TResponse<T>&)> Callback);
 
    void Resend();
 
private:
    FRequestBuilder& Json(const FString& Json);
    void SendInternal();
 
    TSharedPtr<const FHttpClient> Client;
    FHttpRequestPtr Request;
    FString BaseUrl;
    FQueryParameters QueryParameters;
    TFunction<void(const FHttpResponse&)> RetainedCallback;
};
 
template <class T>
FRequestBuilder& FRequestBuilder::Json(const T& Struct, ENamingConvention NamingConvention)
{
    const FString JsonBody = Json::Serialize(Struct, NamingConvention);
    return Json(JsonBody);
}
 
template <class T>
void FRequestBuilder::Send(TFunction<void(const TResponse<T>&)> Callback)
{
    Send(
        [Callback](const FHttpResponse& Response)
        {
            if (Callback)
            {
                Callback(TResponse<T>(Response));
            }
        });
}