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

package/cpp/TursoSyncIoItemHostObject.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+// Forward declarations for Turso C API types
+extern "C" {
+    struct turso_sync_io_item;
+    typedef struct turso_sync_io_item turso_sync_io_item_t;
+}
+
+namespace turso {
+
+using namespace facebook;
+
+/**
+ * TursoSyncIoItemHostObject wraps turso_sync_io_item_t* (IO queue item for fetch/fs operations).
+ * 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 TursoSyncIoItemHostObject : public jsi::HostObject {
+public:
+    TursoSyncIoItemHostObject(turso_sync_io_item_t* item) : item_(item) {}
+    ~TursoSyncIoItemHostObject();
+
+    // 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_io_item_t* getIoItem() const { return item_; }
+
+private:
+    turso_sync_io_item_t* item_ = 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 getKind(jsi::Runtime &rt);
+    jsi::Value getHttpRequest(jsi::Runtime &rt);
+    jsi::Value getFullReadPath(jsi::Runtime &rt);
+    jsi::Value getFullWriteRequest(jsi::Runtime &rt);
+    jsi::Value poison(jsi::Runtime &rt, const jsi::Value *args, size_t count);
+    jsi::Value setStatus(jsi::Runtime &rt, const jsi::Value *args, size_t count);
+    jsi::Value pushBuffer(jsi::Runtime &rt, const jsi::Value *args, size_t count);
+    jsi::Value done(jsi::Runtime &rt);
+};
+
+} // namespace turso

package/cpp/TursoSyncOperationHostObject.cpp

@@ -0,0 +1,168 @@
+#include "TursoSyncOperationHostObject.h"
+#include "TursoConnectionHostObject.h"
+#include "TursoSyncChangesHostObject.h"
+
+extern "C" {
+#include <turso_sync.h>
+}
+
+namespace turso {
+
+TursoSyncOperationHostObject::~TursoSyncOperationHostObject() {
+    if (op_) {
+        turso_sync_operation_deinit(op_);
+        op_ = nullptr;
+    }
+}
+
+void TursoSyncOperationHostObject::throwError(jsi::Runtime &rt, const char *error) {
+    throw jsi::JSError(rt, error ? error : "Unknown error");
+}
+
+jsi::Value TursoSyncOperationHostObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+    auto propName = name.utf8(rt);
+
+    if (propName == "resume") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->resume(rt);
+            }
+        );
+    }
+
+    if (propName == "resultKind") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->resultKind(rt);
+            }
+        );
+    }
+
+    if (propName == "extractConnection") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->extractConnection(rt);
+            }
+        );
+    }
+
+    if (propName == "extractChanges") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->extractChanges(rt);
+            }
+        );
+    }
+
+    if (propName == "extractStats") {
+        return jsi::Function::createFromHostFunction(
+            rt, name, 0,
+            [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+                return this->extractStats(rt);
+            }
+        );
+    }
+
+    return jsi::Value::undefined();
+}
+
+void TursoSyncOperationHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value) {
+    // Read-only object
+}
+
+std::vector<jsi::PropNameID> TursoSyncOperationHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> props;
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "resume"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "resultKind"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "extractConnection"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "extractChanges"));
+    props.emplace_back(jsi::PropNameID::forAscii(rt, "extractStats"));
+    return props;
+}
+
+// 1:1 C API mapping - NO logic, just calls through to C API
+
+jsi::Value TursoSyncOperationHostObject::resume(jsi::Runtime &rt) {
+    const char* error = nullptr;
+    turso_status_code_t status = turso_sync_operation_resume(op_, &error);
+
+    if (status != TURSO_OK && status != TURSO_DONE && status != TURSO_IO) {
+        throwError(rt, error);
+    }
+
+    // Return status code (TURSO_DONE, TURSO_IO, etc.)
+    return jsi::Value(static_cast<int>(status));
+}
+
+jsi::Value TursoSyncOperationHostObject::resultKind(jsi::Runtime &rt) {
+    turso_sync_operation_result_type_t kind = turso_sync_operation_result_kind(op_);
+    return jsi::Value(static_cast<int>(kind));
+}
+
+jsi::Value TursoSyncOperationHostObject::extractConnection(jsi::Runtime &rt) {
+    const turso_connection_t* connection = nullptr;
+    turso_status_code_t status = turso_sync_operation_result_extract_connection(op_, &connection);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to extract connection from operation result");
+    }
+
+    auto connectionObj = std::make_shared<TursoConnectionHostObject>(
+        const_cast<turso_connection_t*>(connection)
+    );
+    return jsi::Object::createFromHostObject(rt, connectionObj);
+}
+
+jsi::Value TursoSyncOperationHostObject::extractChanges(jsi::Runtime &rt) {
+    const turso_sync_changes_t* changes = nullptr;
+    turso_status_code_t status = turso_sync_operation_result_extract_changes(op_, &changes);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to extract changes from operation result");
+    }
+
+    // If no changes, return null
+    if (!changes) {
+        return jsi::Value::null();
+    }
+
+    auto changesObj = std::make_shared<TursoSyncChangesHostObject>(
+        const_cast<turso_sync_changes_t*>(changes)
+    );
+    return jsi::Object::createFromHostObject(rt, changesObj);
+}
+
+jsi::Value TursoSyncOperationHostObject::extractStats(jsi::Runtime &rt) {
+    turso_sync_stats_t stats;
+    turso_status_code_t status = turso_sync_operation_result_extract_stats(op_, &stats);
+
+    if (status != TURSO_OK) {
+        throw jsi::JSError(rt, "Failed to extract stats from operation result");
+    }
+
+    // Convert stats to JS object
+    jsi::Object result(rt);
+    result.setProperty(rt, "cdcOperations", jsi::Value(static_cast<double>(stats.cdc_operations)));
+    result.setProperty(rt, "mainWalSize", jsi::Value(static_cast<double>(stats.main_wal_size)));
+    result.setProperty(rt, "revertWalSize", jsi::Value(static_cast<double>(stats.revert_wal_size)));
+    result.setProperty(rt, "lastPullUnixTime", jsi::Value(static_cast<double>(stats.last_pull_unix_time)));
+    result.setProperty(rt, "lastPushUnixTime", jsi::Value(static_cast<double>(stats.last_push_unix_time)));
+    result.setProperty(rt, "networkSentBytes", jsi::Value(static_cast<double>(stats.network_sent_bytes)));
+    result.setProperty(rt, "networkReceivedBytes", jsi::Value(static_cast<double>(stats.network_received_bytes)));
+
+    // Convert revision slice to string (if available)
+    if (stats.revision.ptr && stats.revision.len > 0) {
+        std::string revision(static_cast<const char*>(stats.revision.ptr), stats.revision.len);
+        result.setProperty(rt, "revision", jsi::String::createFromUtf8(rt, revision));
+    } else {
+        result.setProperty(rt, "revision", jsi::Value::null());
+    }
+
+    return result;
+}
+
+} // namespace turso

package/cpp/TursoSyncOperationHostObject.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+// Forward declarations for Turso C API types
+extern "C" {
+    struct turso_sync_operation;
+    struct turso_connection;
+    struct turso_sync_changes;
+    typedef struct turso_sync_operation turso_sync_operation_t;
+    typedef struct turso_connection turso_connection_t;
+    typedef struct turso_sync_changes turso_sync_changes_t;
+}
+
+namespace turso {
+
+using namespace facebook;
+
+/**
+ * TursoSyncOperationHostObject wraps turso_sync_operation_t* (async operation handle).
+ * 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 TursoSyncOperationHostObject : public jsi::HostObject {
+public:
+    TursoSyncOperationHostObject(turso_sync_operation_t* op) : op_(op) {}
+    ~TursoSyncOperationHostObject();
+
+    // 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_operation_t* getOperation() const { return op_; }
+
+private:
+    turso_sync_operation_t* op_ = 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 resume(jsi::Runtime &rt);
+    jsi::Value resultKind(jsi::Runtime &rt);
+    jsi::Value extractConnection(jsi::Runtime &rt);
+    jsi::Value extractChanges(jsi::Runtime &rt);
+    jsi::Value extractStats(jsi::Runtime &rt);
+};
+
+} // namespace turso

package/ios/TursoModule.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+@interface Turso : NSObject <RCTBridgeModule>
+
+@property (nonatomic, assign) BOOL setBridgeOnMainQueue;
+
+@end

package/ios/TursoModule.mm

@@ -0,0 +1,95 @@
+#import "TursoModule.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <jsi/jsi.h>
+
+#import "TursoHostObject.h"
+
+@implementation Turso
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (NSDictionary *)constantsToExport {
+    // Get documents directory
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *documentsPath = [paths firstObject];
+
+    // Get library directory
+    NSArray *libraryPaths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
+    NSString *libraryPath = [libraryPaths firstObject];
+
+    // Check for app group (for sharing data between app and extensions)
+    NSString *appGroup = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"Turso_AppGroup"];
+    if (appGroup) {
+        NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:appGroup];
+        if (containerURL) {
+            documentsPath = [containerURL path];
+        }
+    }
+
+    return @{
+        @"IOS_DOCUMENT_PATH": documentsPath ?: [NSNull null],
+        @"IOS_LIBRARY_PATH": libraryPath ?: [NSNull null],
+        @"ANDROID_DATABASE_PATH": [NSNull null],
+        @"ANDROID_FILES_PATH": [NSNull null],
+        @"ANDROID_EXTERNAL_FILES_PATH": [NSNull null]
+    };
+}
+
+- (void)setBridge:(RCTBridge *)bridge {
+    _bridge = bridge;
+
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+    if (!cxxBridge.runtime) {
+        return;
+    }
+
+    [self installLibrary];
+}
+
+- (void)installLibrary {
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+    if (!cxxBridge.runtime) {
+        return;
+    }
+
+    facebook::jsi::Runtime *runtime = (facebook::jsi::Runtime *)cxxBridge.runtime;
+    if (!runtime) {
+        return;
+    }
+
+    // Get the documents directory for database storage
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *documentsPath = [paths firstObject];
+
+    // Check for app group (for sharing data between app and extensions)
+    NSString *appGroup = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"Turso_AppGroup"];
+    if (appGroup) {
+        NSURL *containerURL = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:appGroup];
+        if (containerURL) {
+            documentsPath = [containerURL path];
+        }
+    }
+
+    // Get the call invoker
+    auto callInvoker = _bridge.jsCallInvoker;
+
+    // Install the Turso module
+    turso::install(*runtime, callInvoker, [documentsPath UTF8String]);
+}
+
+// Synchronous method to check if the module is installed
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+    [self installLibrary];
+    return @YES;
+}
+
+@end