@tursodatabase/sync-react-native 0.5.0-pre.4

package/cpp/TursoSyncDatabaseHostObject.cpp

@@ -0,0 +1,328 @@
+#include "TursoSyncDatabaseHostObject.h"
+#include "TursoSyncOperationHostObject.h"
+#include "TursoSyncIoItemHostObject.h"
+#include "TursoSyncChangesHostObject.h"
+
+extern "C" {
+#include <turso_sync.h>
+}
+
+namespace turso {
+
+TursoSyncDatabaseHostObject::~TursoSyncDatabaseHostObject() {
+    if (db_) {
+        turso_sync_database_deinit(db_);
+        db_ = nullptr;
+    }
+}
+
+void TursoSyncDatabaseHostObject::throwError(jsi::Runtime &rt, const char *error) {
+    throw jsi::JSError(rt, error ? error : "Unknown error");
+}
+
+jsi::Value TursoSyncDatabaseHostObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+    auto propName = name.utf8(rt);
+
+    if (propName == "open") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->open(rt);
+            }
+        );
+    }
+
+    if (propName == "create") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->create(rt);
+            }
+        );
+    }
+
+    if (propName == "connect") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->connect(rt);
+            }
+        );
+    }
+
+    if (propName == "stats") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->stats(rt);
+            }
+        );
+    }
+
+    if (propName == "checkpoint") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->checkpoint(rt);
+            }
+        );
+    }
+
+    if (propName == "pushChanges") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->pushChanges(rt);
+            }
+        );
+    }
+
+    if (propName == "waitChanges") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->waitChanges(rt);
+            }
+        );
+    }
+
+    if (propName == "applyChanges") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 1,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+                return this->applyChanges(rt, args, count);
+            }
+        );
+    }
+
+    if (propName == "ioTakeItem") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->ioTakeItem(rt);
+            }
+        );
+    }
+
+    if (propName == "ioStepCallbacks") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->ioStepCallbacks(rt);
+            }
+        );
+    }
+
+    if (propName == "close") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->close(rt);
+            }
+        );
+    }
+
+    return jsi::Value::undefined();
+}
+
+void TursoSyncDatabaseHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value) {
+    // Read-only object
+}
+
+std::vector<jsi::PropNameID> TursoSyncDatabaseHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> props;
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "open"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "create"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "connect"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "stats"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "checkpoint"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "pushChanges"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "waitChanges"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "applyChanges"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "ioTakeItem"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "ioStepCallbacks"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "close"));
+    return props;
+}
+
+// 1:1 C API mapping - NO logic, just calls through to C API
+
+jsi::Value TursoSyncDatabaseHostObject::open(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_open(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    // Wrap operation in TursoSyncOperationHostObject
+    // Cast away const since we're transferring ownership
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::create(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_create(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::connect(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_connect(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::stats(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_stats(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::checkpoint(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_checkpoint(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::pushChanges(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_push_changes(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::waitChanges(jsi::Runtime &rt) {
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_wait_changes(db_, &operation, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::applyChanges(jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count < 1 || !args[0].isObject()) {
+        throw jsi::JSError(rt, "applyChanges: expected TursoSyncChanges object");
+    }
+
+    // Extract the TursoSyncChangesHostObject from the JSI object
+    auto changesHostObj = std::dynamic_pointer_cast<TursoSyncChangesHostObject>(
+        args[0].asObject(rt).asHostObject(rt)
+    );
+
+    if (!changesHostObj) {
+        throw jsi::JSError(rt, "applyChanges: invalid TursoSyncChanges object");
+    }
+
+    const turso_sync_changes_t* changes = changesHostObj->getChanges();
+    const turso_sync_operation_t* operation = nullptr;
+    const char* error = nullptr;
+
+    turso_status_code_t status = turso_sync_database_apply_changes(db_, changes, &operation, &error);
+
+    // Note: changes ownership is transferred to turso_sync_database_apply_changes
+    // Mark the changes object as consumed so it won't try to deinit
+    changesHostObj->markConsumed();
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    auto operationObj = std::make_shared<TursoSyncOperationHostObject>(
+        const_cast<turso_sync_operation_t*>(operation)
+    );
+    return jsi::Object::createFromHostObject(rt, operationObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::ioTakeItem(jsi::Runtime &rt) {
+    const turso_sync_io_item_t* item = nullptr;
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_io_take_item(db_, &item, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    // If no item available, return null
+    if (!item) {
+        return jsi::Value::null();
+    }
+
+    auto itemObj = std::make_shared<TursoSyncIoItemHostObject>(
+        const_cast<turso_sync_io_item_t*>(item)
+    );
+    return jsi::Object::createFromHostObject(rt, itemObj);
+}
+
+jsi::Value TursoSyncDatabaseHostObject::ioStepCallbacks(jsi::Runtime &rt) {
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_database_io_step_callbacks(db_, &error);
+
+    if (status != TURSO_OK) {
+        throwError(rt, error);
+    }
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value TursoSyncDatabaseHostObject::close(jsi::Runtime &rt) {
+    // turso_sync_database_close doesn't exist in the C API
+    // Closing happens in destructor via turso_sync_database_deinit
+    return jsi::Value::undefined();
+}
+
+} // namespace turso

package/cpp/TursoSyncDatabaseHostObject.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+// Forward declarations for Turso C API types
+extern "C" {
+    struct turso_sync_database;
+    struct turso_sync_operation;
+    struct turso_sync_io_item;
+    struct turso_sync_changes;
+    typedef struct turso_sync_database turso_sync_database_t;
+    typedef struct turso_sync_operation turso_sync_operation_t;
+    typedef struct turso_sync_io_item turso_sync_io_item_t;
+    typedef struct turso_sync_changes turso_sync_changes_t;
+}
+
+namespace turso {
+
+using namespace facebook;
+
+/**
+ * TursoSyncDatabaseHostObject wraps turso_sync_database_t* (sync SDK-KIT type for embedded replica).
+ * This is a THIN wrapper - 1:1 mapping of SDK-KIT C API with NO logic.
+ * All logic belongs in TypeScript or Rust, not here.
+ */
+class TursoSyncDatabaseHostObject : public jsi::HostObject {
+public:
+    TursoSyncDatabaseHostObject(turso_sync_database_t* db) : db_(db) {}
+    ~TursoSyncDatabaseHostObject();
+
+    // JSI HostObject interface
+    jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name) override;
+    void set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value) override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    // Direct access to wrapped pointer (for internal use)
+    turso_sync_database_t* getSyncDatabase() const { return db_; }
+
+private:
+    turso_sync_database_t* db_ = nullptr;
+
+    // Helper to throw JS errors
+    void throwError(jsi::Runtime &rt, const char *error);
+
+    // 1:1 C API mapping methods (NO logic - just calls through to C API)
+    jsi::Value open(jsi::Runtime &rt);
+    jsi::Value create(jsi::Runtime &rt);
+    jsi::Value connect(jsi::Runtime &rt);
+    jsi::Value stats(jsi::Runtime &rt);
+    jsi::Value checkpoint(jsi::Runtime &rt);
+    jsi::Value pushChanges(jsi::Runtime &rt);
+    jsi::Value waitChanges(jsi::Runtime &rt);
+    jsi::Value applyChanges(jsi::Runtime &rt, const jsi::Value *args, size_t count);
+    jsi::Value ioTakeItem(jsi::Runtime &rt);
+    jsi::Value ioStepCallbacks(jsi::Runtime &rt);
+    jsi::Value close(jsi::Runtime &rt);
+};
+
+} // namespace turso

package/cpp/TursoSyncIoItemHostObject.cpp

@@ -0,0 +1,304 @@
+#include "TursoSyncIoItemHostObject.h"
+
+extern "C" {
+#include <turso_sync.h>
+}
+
+namespace turso {
+
+TursoSyncIoItemHostObject::~TursoSyncIoItemHostObject() {
+    if (item_) {
+        turso_sync_database_io_item_deinit(item_);
+        item_ = nullptr;
+    }
+}
+
+void TursoSyncIoItemHostObject::throwError(jsi::Runtime &rt, const char *error) {
+    throw jsi::JSError(rt, error ? error : "Unknown error");
+}
+
+jsi::Value TursoSyncIoItemHostObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+    auto propName = name.utf8(rt);
+
+    if (propName == "getKind") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->getKind(rt);
+            }
+        );
+    }
+
+    if (propName == "getHttpRequest") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->getHttpRequest(rt);
+            }
+        );
+    }
+
+    if (propName == "getFullReadPath") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->getFullReadPath(rt);
+            }
+        );
+    }
+
+    if (propName == "getFullWriteRequest") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->getFullWriteRequest(rt);
+            }
+        );
+    }
+
+    if (propName == "poison") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 1,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+                return this->poison(rt, args, count);
+            }
+        );
+    }
+
+    if (propName == "setStatus") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 1,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+                return this->setStatus(rt, args, count);
+            }
+        );
+    }
+
+    if (propName == "pushBuffer") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 1,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+                return this->pushBuffer(rt, args, count);
+            }
+        );
+    }
+
+    if (propName == "done") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->done(rt);
+            }
+        );
+    }
+
+    return jsi::Value::undefined();
+}
+
+void TursoSyncIoItemHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value) {
+    // Read-only object
+}
+
+std::vector<jsi::PropNameID> TursoSyncIoItemHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> props;
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "getKind"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "getHttpRequest"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "getFullReadPath"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "getFullWriteRequest"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "poison"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "setStatus"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "pushBuffer"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "done"));
+    return props;
+}
+
+// 1:1 C API mapping - NO logic, just calls through to C API
+
+jsi::Value TursoSyncIoItemHostObject::getKind(jsi::Runtime &rt) {
+    turso_sync_io_request_type_t kind = turso_sync_database_io_request_kind(item_);
+
+    // Return string representation
+    switch (kind) {
+        case TURSO_SYNC_IO_HTTP:
+            return jsi::String::createFromAscii(rt, "HTTP");
+        case TURSO_SYNC_IO_FULL_READ:
+            return jsi::String::createFromAscii(rt, "FULL_READ");
+        case TURSO_SYNC_IO_FULL_WRITE:
+            return jsi::String::createFromAscii(rt, "FULL_WRITE");
+        default:
+            return jsi::String::createFromAscii(rt, "NONE");
+    }
+}
+
+jsi::Value TursoSyncIoItemHostObject::getHttpRequest(jsi::Runtime &rt) {
+    turso_sync_io_http_request_t request;
+    turso_status_code_t status = turso_sync_database_io_request_http(item_, &request);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to get HTTP request");
+    }
+
+    jsi::Object result(rt);
+
+    // URL (may be null/empty)
+    if (request.url.ptr && request.url.len > 0) {
+        std::string url(static_cast<const char*>(request.url.ptr), request.url.len);
+        result.setProperty(rt, "url", jsi::String::createFromUtf8(rt, url));
+    } else {
+        result.setProperty(rt, "url", jsi::Value::null());
+    }
+
+    // Method
+    if (request.method.ptr && request.method.len > 0) {
+        std::string method(static_cast<const char*>(request.method.ptr), request.method.len);
+        result.setProperty(rt, "method", jsi::String::createFromUtf8(rt, method));
+    }
+
+    // Path
+    if (request.path.ptr && request.path.len > 0) {
+        std::string path(static_cast<const char*>(request.path.ptr), request.path.len);
+        result.setProperty(rt, "path", jsi::String::createFromUtf8(rt, path));
+    }
+
+    // Body (may be empty)
+    if (request.body.ptr && request.body.len > 0) {
+        // Create ArrayBuffer for body
+        jsi::Function arrayBufferCtor = rt.global().getPropertyAsFunction(rt, "ArrayBuffer");
+        jsi::Object arrayBuffer = arrayBufferCtor.callAsConstructor(rt, static_cast<int>(request.body.len)).asObject(rt);
+        jsi::ArrayBuffer buf = arrayBuffer.getArrayBuffer(rt);
+        memcpy(buf.data(rt), request.body.ptr, request.body.len);
+        result.setProperty(rt, "body", arrayBuffer);
+    } else {
+        result.setProperty(rt, "body", jsi::Value::null());
+    }
+
+    // Headers
+    jsi::Object headers(rt);
+    for (int32_t i = 0; i < request.headers; i++) {
+        turso_sync_io_http_header_t header;
+        turso_status_code_t header_status = turso_sync_database_io_request_http_header(item_, i, &header);
+
+        if (header_status == TURSO_OK && header.key.ptr && header.value.ptr) {
+            std::string key(static_cast<const char*>(header.key.ptr), header.key.len);
+            std::string value(static_cast<const char*>(header.value.ptr), header.value.len);
+            headers.setProperty(rt, key.c_str(), jsi::String::createFromUtf8(rt, value));
+        }
+    }
+    result.setProperty(rt, "headers", headers);
+
+    return result;
+}
+
+jsi::Value TursoSyncIoItemHostObject::getFullReadPath(jsi::Runtime &rt) {
+    turso_sync_io_full_read_request_t request;
+    turso_status_code_t status = turso_sync_database_io_request_full_read(item_, &request);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to get full read request");
+    }
+
+    if (request.path.ptr && request.path.len > 0) {
+        std::string path(static_cast<const char*>(request.path.ptr), request.path.len);
+        return jsi::String::createFromUtf8(rt, path);
+    }
+
+    return jsi::Value::null();
+}
+
+jsi::Value TursoSyncIoItemHostObject::getFullWriteRequest(jsi::Runtime &rt) {
+    turso_sync_io_full_write_request_t request;
+    turso_status_code_t status = turso_sync_database_io_request_full_write(item_, &request);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to get full write request");
+    }
+
+    jsi::Object result(rt);
+
+    // Path
+    if (request.path.ptr && request.path.len > 0) {
+        std::string path(static_cast<const char*>(request.path.ptr), request.path.len);
+        result.setProperty(rt, "path", jsi::String::createFromUtf8(rt, path));
+    }
+
+    // Content
+    if (request.content.ptr && request.content.len > 0) {
+        jsi::Function arrayBufferCtor = rt.global().getPropertyAsFunction(rt, "ArrayBuffer");
+        jsi::Object arrayBuffer = arrayBufferCtor.callAsConstructor(rt, static_cast<int>(request.content.len)).asObject(rt);
+        jsi::ArrayBuffer buf = arrayBuffer.getArrayBuffer(rt);
+        memcpy(buf.data(rt), request.content.ptr, request.content.len);
+        result.setProperty(rt, "content", arrayBuffer);
+    } else {
+        result.setProperty(rt, "content", jsi::Value::null());
+    }
+
+    return result;
+}
+
+jsi::Value TursoSyncIoItemHostObject::poison(jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count < 1 || !args[0].isString()) {
+        throw jsi::JSError(rt, "poison: expected string argument (error message)");
+    }
+
+    std::string error = args[0].asString(rt).utf8(rt);
+    turso_slice_ref_t error_slice;
+    error_slice.ptr = error.c_str();
+    error_slice.len = error.length();
+
+    turso_status_code_t status = turso_sync_database_io_poison(item_, &error_slice);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to poison IO item");
+    }
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value TursoSyncIoItemHostObject::setStatus(jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count < 1 || !args[0].isNumber()) {
+        throw jsi::JSError(rt, "setStatus: expected number argument (status code)");
+    }
+
+    int32_t status_code = static_cast<int32_t>(args[0].asNumber());
+    turso_status_code_t status = turso_sync_database_io_status(item_, status_code);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to set IO status");
+    }
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value TursoSyncIoItemHostObject::pushBuffer(jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count < 1 || !args[0].isObject()) {
+        throw jsi::JSError(rt, "pushBuffer: expected ArrayBuffer argument");
+    }
+
+    auto arrayBuffer = args[0].asObject(rt).getArrayBuffer(rt);
+    const char* data = reinterpret_cast<const char*>(arrayBuffer.data(rt));
+    size_t len = arrayBuffer.size(rt);
+
+    turso_slice_ref_t buffer_slice;
+    buffer_slice.ptr = data;
+    buffer_slice.len = len;
+
+    turso_status_code_t status = turso_sync_database_io_push_buffer(item_, &buffer_slice);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to push buffer to IO item");
+    }
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value TursoSyncIoItemHostObject::done(jsi::Runtime &rt) {
+    turso_status_code_t status = turso_sync_database_io_done(item_);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to mark IO item as done");
+    }
+
+    return jsi::Value::undefined();
+}
+
+} // namespace turso