fetch.h

Go to the documentation of this file.

#pragma once

 
#include "fl/namespace.h"
#include "fl/promise.h"
#include "fl/string.h"
#include "fl/vector.h"
#include "fl/map.h"
#include "fl/hash_map.h"
#include "fl/optional.h"
#include "fl/function.h"
#include "fl/ptr.h"
#include "fl/async.h"
#include "fl/mutex.h"
#include "fl/warn.h"
#include "fl/json.h"  // Add JSON support for response.json() method
 
namespace fl {
 
// Forward declarations
class fetch_options;
class FetchManager;
 
#ifdef __EMSCRIPTEN__
// Forward declarations for WASM-specific types (defined in platforms/wasm/js_fetch.h)
class WasmFetchRequest;
class WasmFetch;
using FetchResponseCallback = fl::function<void(const response&)>;
extern WasmFetch wasm_fetch;
#endif

class response {
public:
    response() : 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) {
        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() = default;
    RequestOptions(const fl::string& method_name) : method(method_name) {}
};

class fetch_options {
public:
    explicit fetch_options(const fl::string& url) : mUrl(url) {}
    fetch_options(const fl::string& url, const RequestOptions& options) 
        : mUrl(url), mOptions(options) {}
    
    fetch_options& method(const fl::string& http_method) {
        mOptions.method = http_method;
        return *this;
    }
    
    fetch_options& header(const fl::string& name, const fl::string& value) {
        mOptions.headers[name] = value;
        return *this;
    }
    
    fetch_options& body(const fl::string& data) {
        mOptions.body = data;
        return *this;
    }
    
    fetch_options& json(const fl::string& json_data) {
        mOptions.body = json_data;
        mOptions.headers["Content-Type"] = "application/json";
        return *this;
    }
    
    fetch_options& 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 async_runner {
public:
    static FetchManager& instance();
    
    void register_promise(const fl::promise<response>& promise);
    
    // async_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::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::promise<response> fetch_get(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_post(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_put(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_delete(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_head(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_http_options(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_patch(const fl::string& url, const fetch_options& request = fetch_options(""));

fl::promise<response> fetch_request(const fl::string& url, const RequestOptions& options = RequestOptions());

void fetch_update();

fl::size fetch_active_requests();

fl::promise<response> execute_fetch_request(const fl::string& url, const fetch_options& request);
 
} // namespace fl