fetch.h

Go to the documentation of this file.

#pragma once

 
#include "fl/task/promise.h"
#include "fl/stl/string.h"
#include "fl/stl/vector.h"
#include "fl/stl/map.h"
#include "fl/stl/unordered_map.h"
#include "fl/stl/optional.h"
#include "fl/stl/function.h"
#include "fl/stl/shared_ptr.h"
#include "fl/task/executor.h"
#include "fl/stl/mutex.h"
#include "fl/log/log.h"
#include "fl/stl/json.h"  // Add JSON support for response.json() method
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace net {
namespace http {
 
// Forward declarations
class FetchOptions;
class FetchManager;
class Response;

class Response {
public:
    Response() FL_NOEXCEPT : mStatusCode(200), mStatusText("OK") {}
    Response(int status_code) : mStatusCode(status_code), mStatusText(get_default_status_text(status_code)) {}
    Response(int status_code, const fl::string& status_text)
        : mStatusCode(status_code), mStatusText(status_text) {}
    
    int status() const { return mStatusCode; }
    
    const fl::string& status_text() const { return mStatusText; }
    
    bool ok() const { return mStatusCode >= 200 && mStatusCode < 300; }
    
    const fl::string& text() const { return mBody; }
    
    fl::optional<fl::string> get_header(const fl::string& name) const {
        auto it = mHeaders.find(name);
        if (it != mHeaders.end()) {
            return fl::make_optional(it->second);
        }
        return fl::nullopt;
    }
    
    fl::optional<fl::string> get_content_type() const {
        return get_header("content-type");
    }
    
    const fl::string& get_body_text() const { return mBody; }
    
    fl::json json() const;
    
    bool is_json() const {
        auto content_type = get_content_type();
        if (content_type.has_value()) {
            fl::string ct = *content_type;
            // Check for various JSON content types (case-insensitive)
            return ct.find("json") != fl::string::npos;
        }
        return false;
    }
    
    void set_status(int status_code) { mStatusCode = status_code; }
    void set_status_text(const fl::string& status_text) { mStatusText = status_text; }
    void set_text(const fl::string& body) { mBody = body; }  // Backward compatibility
    void set_body(const fl::string& body) { mBody = body; }
    void set_header(const fl::string& name, const fl::string& value) {
        mHeaders[name] = value;
    }
 
private:
    int mStatusCode;
    fl::string mStatusText;
    fl::string mBody;
    fl_map<fl::string, fl::string> mHeaders;
    
    // JSON parsing cache
    mutable fl::optional<fl::json> mCachedJson;  // Lazy-loaded JSON cache
    mutable bool mJsonParsed = false;            // Track parsing attempts
    
    fl::json parse_json_body() const {
        fl::json parsed = fl::json::parse(mBody);
        if (parsed.is_null() && (!mBody.empty())) {
            // If parsing failed but we have content, return null JSON
            // This allows safe chaining: resp.json()["key"] | default
            return fl::json(nullptr);
        }
        return parsed;
    }
    
    static fl::string get_default_status_text(int status) {  // okay static in header
        switch (status) {
            case 200: return "OK";
            case 400: return "Bad Request";
            case 401: return "Unauthorized";
            case 403: return "Forbidden";
            case 404: return "Not Found";
            case 500: return "Internal Server Error";
            case 501: return "Not Implemented";
            case 502: return "Bad Gateway";
            case 503: return "Service Unavailable";
            default: return "Unknown";
        }
    }
};
 
 

using FetchCallback = fl::function<void(const Response&)>;

struct RequestOptions {
    fl::string method = "GET";
    fl_map<fl::string, fl::string> headers;
    fl::string body;
    int timeout_ms = 10000;  // 10 second default
    
    RequestOptions() FL_NOEXCEPT = default;
    RequestOptions(const fl::string& method_name) : method(method_name) {}
};

class FetchOptions {
public:
    explicit FetchOptions(const fl::string& url) : mUrl(url) {}
    FetchOptions(const fl::string& url, const RequestOptions& options)
        : mUrl(url), mOptions(options) {}

    FetchOptions& method(const fl::string& http_method) {
        mOptions.method = http_method;
        return *this;
    }

    FetchOptions& header(const fl::string& name, const fl::string& value) {
        mOptions.headers[name] = value;
        return *this;
    }

    FetchOptions& body(const fl::string& data) {
        mOptions.body = data;
        return *this;
    }

    FetchOptions& json(const fl::string& json_data) {
        mOptions.body = json_data;
        mOptions.headers["Content-Type"] = "application/json";
        return *this;
    }

    FetchOptions& timeout(int timeout_ms) {
        mOptions.timeout_ms = timeout_ms;
        return *this;
    }
    
    const fl::string& url() const { return mUrl; }
    
    const RequestOptions& options() const { return mOptions; }
 
private:
    fl::string mUrl;
    RequestOptions mOptions;
    
    friend class FetchManager;
};
 
class FetchEngineListener;

class FetchManager : public task::Runner {
public:
    static FetchManager& instance();
    
    void register_promise(const fl::task::Promise<Response>& promise);
    
    // task::Runner interface
    void update() override;
    bool has_active_tasks() const override;
    size_t active_task_count() const override;
    
    // Legacy API
    fl::size active_requests() const;
    void cleanup_completed_promises();
    
private:
    fl::vector<fl::task::Promise<Response>> mActivePromises;
    fl::unique_ptr<FetchEngineListener> mEngineListener;
};
 
// ========== Simple Callback API (Backward Compatible) ==========

void fetch(const fl::string& url, const FetchCallback& callback);

inline void fetch(const char* url, const FetchCallback& callback) {
    fetch(fl::string(url), callback);
}
 
// ========== Promise-Based API (JavaScript-like) ==========

fl::task::Promise<Response> fetch_get(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_post(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_put(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_delete(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_head(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_http_options(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_patch(const fl::string& url, const FetchOptions& request = FetchOptions(""));

fl::task::Promise<Response> fetch_request(const fl::string& url, const RequestOptions& options = RequestOptions());

void fetch_update();

fl::size fetch_active_requests();

fl::task::Promise<Response> execute_fetch_request(const fl::string& url, const FetchOptions& request);
 
} // namespace http
} // namespace net
} // namespace fl