react-native-nitro-sse 0.1.0-beta.0

package/ios/NitroSse.swift

@@ -0,0 +1,311 @@
+import Foundation
+import NitroModules
+import LDSwiftEventSource
+
+/**
+ * NitroSse implements a high-performance SSE client for iOS using LDSwiftEventSource.
+ *
+ * ARCHITECTURE DECISIONS:
+ * 1. Threading Serialization: All operations are strictly serialized on a dedicated background queue (sseQueue).
+ *    This ensures thread-safety for internal states (buffer, backoff) and prevents blocking the JS/Main threads.
+ * 2. Mobile Survival Logic: Implements a "Hibernation" pattern. When the app enters the background, 
+ *    we flush remaining events and stop the socket to preserve battery and follow Apple's background policies. 
+ *    The connection is automatically resumed from the last known ID when the app returns to foreground.
+ * 3. Batching: Reduces JSI bridge overhead by accumulating events and dispatching them 
+ *    as a single array after a configurable interval.
+ */
+class NitroSse: HybridNitroSseSpec, EventHandler {
+    private var eventSource: EventSource?
+    private var config: SseConfig?
+    private var onEventsCallback: ((_ events: [SseEvent]) -> Void)?
+    private var isRunning: Bool = false
+    
+    private var eventBuffer: [SseEvent] = []
+    private var isFlushPending: Bool = false
+    
+    private var backoffCounter: Int = 0
+    private var lastProcessedId: String? = nil
+    
+    private var totalBytesReceived: Double = 0
+    private var reconnectCount: Double = 0
+    private var lastErrorTime: Double? = nil
+    private var lastErrorCode: String? = nil
+    
+    private let defaultRetryDelay: TimeInterval = 3.0
+    private let baseBackoffDelay: TimeInterval = 2.0
+    private let maxBackoffDelay: TimeInterval = 30.0
+    
+    private let sseQueue = DispatchQueue(label: "com.margelo.nitro.sse", qos: .utility)
+    private var backgroundTaskIdentifier: UIBackgroundTaskIdentifier = .invalid
+    private var wasRunningBeforeHibernation: Bool = false
+
+    func setup(config: SseConfig, onEvent: @escaping ((_ events: [SseEvent]) -> Void)) throws {
+        self.config = config
+        self.onEventsCallback = onEvent
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(handleAppDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(handleAppWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
+    }
+    
+    @objc private func handleAppDidEnterBackground() {
+        sseQueue.async {
+            guard self.isRunning else { return }
+            
+            self.wasRunningBeforeHibernation = true
+            print("[NitroSse] App backgrounded. Hibernating connection.")
+            
+            self.backgroundTaskIdentifier = UIApplication.shared.beginBackgroundTask(withName: "NitroSse-GracefulHibernate") {
+                self.cleanupBackgroundTask()
+            }
+            
+            self.flushEventsToJs()
+            
+            self.eventSource?.stop()
+            self.eventSource = nil
+            self.isRunning = false
+            
+            self.cleanupBackgroundTask()
+        }
+    }
+    
+    @objc private func handleAppWillEnterForeground() {
+        sseQueue.async {
+            self.cleanupBackgroundTask()
+            if self.wasRunningBeforeHibernation {
+                print("[NitroSse] App foregrounded. Resuming stream.")
+                self.wasRunningBeforeHibernation = false
+                try? self.start()
+            }
+        }
+    }
+    
+    private func cleanupBackgroundTask() {
+        if self.backgroundTaskIdentifier != .invalid {
+            UIApplication.shared.endBackgroundTask(self.backgroundTaskIdentifier)
+            self.backgroundTaskIdentifier = .invalid
+        }
+    }
+
+    private func pushEventToBuffer(_ event: SseEvent) {
+        dispatchPrecondition(condition: .onQueue(sseQueue))
+        
+        let batchIntervalMs = config?.batchingIntervalMs ?? 0
+        let bufferCapacity = Int(config?.maxBufferSize ?? 1000)
+        
+        while eventBuffer.count >= bufferCapacity {
+            eventBuffer.removeFirst()
+        }
+        eventBuffer.append(event)
+        
+        if batchIntervalMs <= 0 {
+            flushEventsToJs()
+        } else if !isFlushPending {
+            isFlushPending = true
+            sseQueue.asyncAfter(deadline: .now() + (Double(batchIntervalMs) / 1000.0)) { [weak self] in
+                self?.flushEventsToJs()
+            }
+        }
+    }
+    
+    private func flushEventsToJs() {
+        dispatchPrecondition(condition: .onQueue(sseQueue))
+        guard !eventBuffer.isEmpty else { 
+            isFlushPending = false
+            return 
+        }
+        
+        let batch = eventBuffer
+        eventBuffer.removeAll()
+        isFlushPending = false
+        onEventsCallback?(batch)
+    }
+
+    func setLastProcessedId(id: String) {
+        sseQueue.async {
+            self.lastProcessedId = id
+        }
+    }
+
+    func updateHeaders(headers: [String: String]) throws {
+        sseQueue.async {
+            if let currentConfig = self.config {
+                self.config = SseConfig(
+                    url: currentConfig.url,
+                    method: currentConfig.method,
+                    headers: headers,
+                    body: currentConfig.body,
+                    backgroundExecution: currentConfig.backgroundExecution,
+                    batchingIntervalMs: currentConfig.batchingIntervalMs,
+                    maxBufferSize: currentConfig.maxBufferSize
+                )
+            }
+        }
+    }
+
+    func getStats() throws -> SseStats {
+        return sseQueue.sync {
+            return SseStats(
+                totalBytesReceived: totalBytesReceived,
+                reconnectCount: reconnectCount,
+                lastErrorTime: lastErrorTime,
+                lastErrorCode: lastErrorCode
+            )
+        }
+    }
+
+    func start() throws {
+        sseQueue.async {
+            guard !self.isRunning else { return }
+            self.isRunning = true
+            self.backoffCounter = 0
+            self.establishConnection()
+        }
+    }
+
+    private func establishConnection() {
+        dispatchPrecondition(condition: .onQueue(sseQueue))
+        guard isRunning, let config = config, let url = URL(string: config.url) else { return }
+        
+        var esConfig = EventSource.Config(handler: self, url: url)
+        esConfig.headers = config.headers ?? [:]
+        
+        if let lastId = self.lastProcessedId, !lastId.isEmpty {
+            esConfig.headers["Last-Event-ID"] = lastId
+        }
+        
+        esConfig.idleTimeout = 35.0
+        esConfig.method = config.method?.stringValue.uppercased() ?? "GET"
+        esConfig.body = config.body?.data(using: .utf8)
+        
+        eventSource = EventSource(config: esConfig)
+        eventSource?.start()
+    }
+
+    func stop() {
+        sseQueue.async {
+            self.isRunning = false
+            self.eventSource?.stop()
+            self.eventSource = nil
+            self.backoffCounter = 0
+            self.eventBuffer.removeAll()
+            self.isFlushPending = false
+            self.cleanupBackgroundTask()
+        }
+    }
+    
+    func onOpened() {
+        sseQueue.async {
+            self.backoffCounter = 0
+            self.pushEventToBuffer(SseEvent(type: .open, data: nil, id: nil, event: nil, message: nil))
+        }
+    }
+    
+    func onClosed() {
+        sseQueue.async {
+            if self.isRunning {
+                self.scheduleAutomaticReconnect(isError: false)
+            }
+        }
+    }
+    
+    func onMessage(eventType: String, messageEvent: MessageEvent) {
+        sseQueue.async {
+            let encodedDataSize = Double(messageEvent.data.utf8.count)
+            let metadataSize = Double(eventType.utf8.count) + Double((messageEvent.lastEventId).utf8.count)
+            self.totalBytesReceived += encodedDataSize + metadataSize
+            
+            self.pushEventToBuffer(SseEvent(type: .message, data: messageEvent.data, id: messageEvent.lastEventId, event: eventType, message: nil))
+        }
+    }
+    
+    func onComment(comment: String) {
+        sseQueue.async {
+            self.totalBytesReceived += Double(comment.utf8.count)
+            self.pushEventToBuffer(SseEvent(type: .heartbeat, data: nil, id: nil, event: nil, message: comment))
+        }
+    }
+    
+    private func extractRetryAfterSeconds(error: Error) -> TimeInterval? {
+        let nsError = error as NSError
+        guard let response = nsError.userInfo["response"] as? HTTPURLResponse else { return nil }
+        guard let retryAfterHeader = response.allHeaderFields["Retry-After"] as? String else { return nil }
+        
+        if let seconds = Double(retryAfterHeader) {
+            return seconds
+        }
+        
+        let rfc1123Formatter = DateFormatter()
+        rfc1123Formatter.locale = Locale(identifier: "en_US_POSIX")
+        rfc1123Formatter.dateFormat = "EEE, dd MMM yyyy HH:mm:ss z"
+        if let date = rfc1123Formatter.date(from: retryAfterHeader) {
+            let timeUntilDate = date.timeIntervalSinceNow
+            return timeUntilDate > 0 ? timeUntilDate : nil
+        }
+        return nil
+    }
+
+    func onError(error: Error) {
+        sseQueue.async {
+            guard self.isRunning else { return }
+            let nsError = error as NSError
+            let statusCode = nsError.code
+            
+            self.reconnectCount += 1
+            self.lastErrorTime = Date().timeIntervalSince1970 * 1000
+            self.lastErrorCode = "\(nsError.domain)(\(statusCode))"
+
+            let isFatalError = (statusCode == 401 || statusCode == 403 || statusCode == 400)
+            if isFatalError {
+                self.pushEventToBuffer(SseEvent(type: .error, data: nil, id: nil, event: nil, message: "Fatal Error (\(statusCode)). Stopping."))
+                self.stop()
+                return
+            }
+
+            let retryAfterSeconds = self.extractRetryAfterSeconds(error: error)
+            if (statusCode == 429 || statusCode == 503), let delay = retryAfterSeconds {
+                let jitter = Double.random(in: 0.5...2.0)
+                let totalDelay = delay + jitter
+                self.pushEventToBuffer(SseEvent(type: .error, data: nil, id: nil, event: nil, message: "Retry-After received (\(statusCode))"))
+                self.scheduleAutomaticReconnectWithFixedDelay(totalDelay)
+                return
+            }
+
+            if statusCode == 429 {
+                self.pushEventToBuffer(SseEvent(type: .error, data: nil, id: nil, event: nil, message: "Rate Limited (429) without Retry-After. Stopping."))
+                self.stop()
+                return
+            }
+            
+            self.pushEventToBuffer(SseEvent(type: .error, data: nil, id: nil, event: nil, message: error.localizedDescription))
+            self.scheduleAutomaticReconnect(isError: true)
+        }
+    }
+    
+    private func scheduleAutomaticReconnectWithFixedDelay(_ delay: TimeInterval) {
+        dispatchPrecondition(condition: .onQueue(sseQueue))
+        eventSource?.stop()
+        sseQueue.asyncAfter(deadline: .now() + delay) { [weak self] in
+            guard let self = self, self.isRunning else { return }
+            self.establishConnection()
+        }
+    }
+    
+    private func scheduleAutomaticReconnect(isError: Bool) {
+        dispatchPrecondition(condition: .onQueue(sseQueue))
+        eventSource?.stop()
+        var delay: TimeInterval = defaultRetryDelay
+        if isError {
+            let exponent = Double(backoffCounter)
+            let base = min(baseBackoffDelay * pow(2.0, exponent), maxBackoffDelay)
+            backoffCounter += 1
+            delay = base * (0.5 + Double.random(in: 0...1))
+        } else {
+            delay = defaultRetryDelay * (0.8 + Double.random(in: 0...0.4))
+        }
+        let safeDelay = max(delay, 2.0)
+        sseQueue.asyncAfter(deadline: .now() + safeDelay) { [weak self] in
+            guard let self = self, self.isRunning else { return }
+            self.establishConnection()
+        }
+    }
+}

package/lib/module/NitroSse.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NitroSse.nitro.js.map

package/lib/module/NitroSse.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroSse.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/SseInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=SseInterface.js.map

package/lib/module/SseInterface.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["SseInterface.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+export * from "./SseInterface.js";
+export * from "./NitroSse.nitro.js";
+
+// Load the Hybrid Object from Native
+let realNitroSse;
+try {
+  realNitroSse = NitroModules.createHybridObject('NitroSse');
+} catch {
+  console.debug('Native NitroSse not found. This might be a test environment or web.');
+}
+
+/**
+ * Public interface to use SSE.
+ */
+if (!realNitroSse || !realNitroSse.setup) {
+  throw new Error('NitroSse: Native module not found. Ensure you have linked the library and built the app for iOS/Android.');
+}
+export const NitroSseModule = realNitroSse;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","realNitroSse","createHybridObject","console","debug","setup","Error","NitroSseModule"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,cAAc,mBAAgB;AAC9B,cAAc,qBAAkB;;AAEhC;AACA,IAAIC,YAAkC;AACtC,IAAI;EACFA,YAAY,GAAGD,YAAY,CAACE,kBAAkB,CAAW,UAAU,CAAC;AACtE,CAAC,CAAC,MAAM;EACNC,OAAO,CAACC,KAAK,CACX,qEACF,CAAC;AACH;;AAEA;AACA;AACA;AACA,IAAI,CAACH,YAAY,IAAI,CAAEA,YAAY,CAASI,KAAK,EAAE;EACjD,MAAM,IAAIC,KAAK,CACb,0GACF,CAAC;AACH;AAEA,OAAO,MAAMC,cAAwB,GAAGN,YAAY","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NitroSse.nitro.d.ts

@@ -0,0 +1,34 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { SseConfig, SseEvent, SseStats } from './SseInterface';
+export interface NitroSse extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Configure SSE and setup event callback.
+     */
+    setup(config: SseConfig, onEvent: (events: SseEvent[]) => void): void;
+    /**
+     * Start the SSE connection.
+     */
+    start(): void;
+    /**
+     * Stop the SSE connection.
+     */
+    stop(): void;
+    /**
+     * Set the last processed event ID.
+     * Native will use this ID to resume connection if interrupted.
+     */
+    setLastProcessedId(id: string): void;
+    /**
+     * Update HTTP headers dynamically (e.g., when token expires).
+     * These headers will be used for subsequent connection/reconnection attempts.
+     */
+    updateHeaders(headers: Record<string, string>): void;
+    /**
+     * Get connection statistics.
+     */
+    getStats(): SseStats;
+}
+//# sourceMappingURL=NitroSse.nitro.d.ts.map

package/lib/typescript/src/NitroSse.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroSse.nitro.d.ts","sourceRoot":"","sources":["../../../src/NitroSse.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEpE,MAAM,WAAW,QACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAEtE;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,IAAI,IAAI,IAAI,CAAC;IAEb;;;OAGG;IACH,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC;;;OAGG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAErD;;OAEG;IACH,QAAQ,IAAI,QAAQ,CAAC;CACtB"}

package/lib/typescript/src/SseInterface.d.ts

@@ -0,0 +1,25 @@
+export type HttpMethod = 'get' | 'post';
+export type SseEventType = 'open' | 'message' | 'error' | 'close' | 'heartbeat';
+export interface SseConfig {
+    url: string;
+    method?: HttpMethod;
+    headers?: Record<string, string>;
+    body?: string;
+    backgroundExecution?: boolean;
+    batchingIntervalMs?: number;
+    maxBufferSize?: number;
+}
+export interface SseEvent {
+    type: SseEventType;
+    data?: string;
+    id?: string;
+    event?: string;
+    message?: string;
+}
+export interface SseStats {
+    totalBytesReceived: number;
+    reconnectCount: number;
+    lastErrorTime?: number;
+    lastErrorCode?: string;
+}
+//# sourceMappingURL=SseInterface.d.ts.map

package/lib/typescript/src/SseInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SseInterface.d.ts","sourceRoot":"","sources":["../../../src/SseInterface.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;AAExC,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;AAEhF,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,5 @@
+import type { NitroSse } from './NitroSse.nitro';
+export * from './SseInterface';
+export * from './NitroSse.nitro';
+export declare const NitroSseModule: NitroSse;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AAqBjC,eAAO,MAAM,cAAc,EAAE,QAAuB,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["nitrosse"],
+  "ios": {
+    "iosModuleName": "NitroSse"
+  },
+  "android": {
+    "androidNamespace": ["nitrosse"],
+    "androidCxxLibName": "nitrosse"
+  },
+  "autolinking": {
+    "NitroSse": {
+      "swift": "NitroSse",
+      "kotlin": "NitroSse"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JFunc_void_std__vector_SseEvent_.hpp

@@ -0,0 +1,100 @@
+///
+/// JFunc_void_std__vector_SseEvent_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "SseEvent.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JSseEvent.hpp"
+#include "SseEventType.hpp"
+#include "JSseEventType.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::nitrosse {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(events: Array<SseEvent>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_SseEvent_: public jni::JavaClass<JFunc_void_std__vector_SseEvent_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/Func_void_std__vector_SseEvent_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_SseEvent_` instance holds through JNI.
+     */
+    void invoke(const std::vector<SseEvent>& events) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JSseEvent>> /* events */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = events.size();
+        jni::local_ref<jni::JArrayClass<JSseEvent>> __array = jni::JArrayClass<JSseEvent>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = events[__i];
+          auto __elementJni = JSseEvent::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_SseEvent_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_SseEvent__cxx final: public jni::HybridClass<JFunc_void_std__vector_SseEvent__cxx, JFunc_void_std__vector_SseEvent_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_SseEvent_::javaobject> fromCpp(const std::function<void(const std::vector<SseEvent>& /* events */)>& func) {
+      return JFunc_void_std__vector_SseEvent__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_SseEvent__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JSseEvent>> events) {
+      _func([&]() {
+              size_t __size = events->size();
+              std::vector<SseEvent> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = events->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<SseEvent>& /* events */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/Func_void_std__vector_SseEvent__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_SseEvent__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_SseEvent__cxx(const std::function<void(const std::vector<SseEvent>& /* events */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<SseEvent>& /* events */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrosse

package/nitrogen/generated/android/c++/JHttpMethod.hpp

@@ -0,0 +1,58 @@
+///
+/// JHttpMethod.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "HttpMethod.hpp"
+
+namespace margelo::nitro::nitrosse {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "HttpMethod" and the the Kotlin enum "HttpMethod".
+   */
+  struct JHttpMethod final: public jni::JavaClass<JHttpMethod> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrosse/HttpMethod;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum HttpMethod.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HttpMethod toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<HttpMethod>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JHttpMethod> fromCpp(HttpMethod value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case HttpMethod::GET:
+          static const auto fieldGET = clazz->getStaticField<JHttpMethod>("GET");
+          return clazz->getStaticFieldValue(fieldGET);
+        case HttpMethod::POST:
+          static const auto fieldPOST = clazz->getStaticField<JHttpMethod>("POST");
+          return clazz->getStaticFieldValue(fieldPOST);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrosse