@dittolive/ditto 4.5.4 → 4.6.0

package/react-native/cpp/src/Utils.cpp

@@ -5,134 +5,130 @@
 #include <thread>
 // #include <condition_variable>
 
-namespace sharedjsi {
+namespace sharedjsi
+{
+
+  std::string pointerToHexString(void const *ptr)
+  {
+    char buffer[20]; // Assuming a 64-bit pointer, 16 characters for address + 2 for "0x" + 1 for null-terminator.
+    snprintf(buffer, sizeof(buffer), "%p", ptr);
+    return std::string(buffer);
+  }
 
-std::string pointerToHexString(void const *ptr) {
-  char buffer[20]; // Assuming a 64-bit pointer, 16 characters for address + 2 for "0x" + 1 for null-terminator.
-  snprintf(buffer, sizeof(buffer), "%p", ptr);
-  return std::string(buffer);
-}
+  // To be used with `Option<slice_ref_uint8_t> (check Rust Core API)
+  slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const &v)
+  {
+    slice_ref_uint8_t it{};
+    it.ptr = v.empty() ? nullptr : v.data();
+    it.len = v.size();
+    return it;
+  }
 
-// To be used with `Option<slice_ref_uint8_t> (check Rust Core API)
-slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const& v) {
-  slice_ref_uint8_t it {};
-  it.ptr = v.empty() ? nullptr : v.data();
-  it.len = v.size();
-  return it;
-}
+  // To be used with non-optional `slice_ref_uint8_t` (check Rust Core API)
+  slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const &v)
+  {
+    slice_ref_uint8_t it{};
+    it.ptr = v.empty() ? (uint8_t *)0xbad000 : v.data();
+    it.len = v.size();
+    return it;
+  }
 
-// To be used with non-optional `slice_ref_uint8_t` (check Rust Core API)
-slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const& v) {
-  slice_ref_uint8_t it {};
-  it.ptr = v.empty() ? (uint8_t *) 0xbad000 : v.data();
-  it.len = v.size();
-  return it;
-}
+  Function sliceBoxedToUInt8Array(Runtime &runtime)
+  {
+    return Function::createFromHostFunction(runtime,
+                                            PropNameID::forAscii(runtime,
+                                                                 STRINGIFIED_FUNC_NAME()),
+                                            0,
+                                            [](Runtime &runtime,
+                                               const Value &thisValue,
+                                               const Value *arguments,
+                                               size_t count) -> Value
+                                            {
+                                              auto fatPtrJs = arguments[0].asObject(runtime);
+                                              auto ptr = jsPointerObjectToCPointer<uint8_t>(runtime, fatPtrJs.getProperty(runtime, "ptr"));
+                                              auto len = static_cast<size_t>(fatPtrJs.getProperty(runtime, "len").asNumber());
+                                              slice_boxed_uint8 slice = {.ptr = ptr, .len = len};
+                                              if (!slice.ptr)
+                                              {
+                                                return Value::null();
+                                              }
+
+                                              auto typedArray = TypedArray<TypedArrayKind::Uint8Array>(runtime, slice.len);
+                                              auto arrayBuffer = typedArray.getBuffer(runtime);
+                                              std::memcpy(arrayBuffer.data(runtime), slice.ptr, slice.len);
+
+                                              ::ditto_c_bytes_free(slice);
+
+                                              return typedArray;
+                                            });
+  }
 
-Function sliceBoxedToUInt8Array(Runtime &runtime) {
-  return Function::createFromHostFunction(runtime,
-                                          PropNameID::forAscii(runtime,
-                                                               STRINGIFIED_FUNC_NAME()),
-                                          0,
-                                          [](Runtime &runtime,
-                                             const Value &thisValue,
-                                             const Value *arguments,
-                                             size_t count) -> Value
-                                          {
-    auto fatPtrJs = arguments[0].asObject(runtime);
-    auto ptr = jsPointerObjectToCPointer<uint8_t>(runtime, fatPtrJs.getProperty(runtime, "ptr"));
-    auto len = static_cast<size_t>(fatPtrJs.getProperty(runtime, "len").asNumber());
-    slice_boxed_uint8 slice = { .ptr = ptr, .len = len };
-    if (!slice.ptr) {
-      return Value::null();
+  std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg)
+  {
+    if (arg.isUndefined() || arg.isNull())
+    {
+      return {};
     }
-
-    auto typedArray = TypedArray<TypedArrayKind::Uint8Array>(runtime, slice.len);
-    auto arrayBuffer = typedArray.getBuffer(runtime);
-    std::memcpy(arrayBuffer.data(runtime), slice.ptr, slice.len);
-
-    ::ditto_c_bytes_free(slice);
-
-    return typedArray;
-  });
-}
-
-std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg) {
-  if (arg.isUndefined() || arg.isNull()) {
-    return {};
+    TypedArrayBase typedArrayBase(runtime, arg.asObject(runtime));
+    return typedArrayBase.toVector(runtime);
   }
-  TypedArrayBase typedArrayBase(runtime, arg.asObject(runtime));
-  return typedArrayBase.toVector(runtime);
-}
-
-std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg) {
-  std::vector<uint8_t> vec = jsTypedArrayToCVector(runtime, arg);
-  return std::string(vec.begin(), vec.end());
-}
-
-Value cSlicedBoxToJSSlicedBox(Runtime &runtime, slice_boxed_uint8 box_c_bytes) {
-  Object obj(runtime);
-  obj.setProperty(runtime, "ptr", cPointerToJSPointerObject<uint8_t>(runtime, box_c_bytes.ptr));
-  obj.setProperty(runtime, "len", static_cast<double>(box_c_bytes.len));
-  return obj;
-}
-
-Function withOutBoxCBytes(Runtime &runtime) {
-  return Function::createFromHostFunction(runtime,
-                                          PropNameID::forAscii(runtime,
-                                                               STRINGIFIED_FUNC_NAME()),
-                                          0,
-                                          [](Runtime &runtime,
-                                             const Value &thisValue,
-                                             const Value *arguments,
-                                             size_t count) -> Value
-                                          {
-    auto callback = arguments[0].asObject(runtime).asFunction(runtime);
-    slice_boxed_uint8 box_c_bytes = { 0 };
-    auto out_box_cbytes = &box_c_bytes;
-    auto out_box_cbytes_js = cPointerToJSPointerObject<slice_boxed_uint8>(runtime, out_box_cbytes);
-    
-    callback.call(runtime, out_box_cbytes_js);
-
-    return cSlicedBoxToJSSlicedBox(runtime, box_c_bytes);
-  });
-}
 
+  std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg)
+  {
+    std::vector<uint8_t> vec = jsTypedArrayToCVector(runtime, arg);
+    return std::string(vec.begin(), vec.end());
+  }
 
+  Value cSlicedBoxToJSSlicedBox(Runtime &runtime, slice_boxed_uint8 box_c_bytes)
+  {
+    Object obj(runtime);
+    obj.setProperty(runtime, "ptr", cPointerToJSPointerObject<uint8_t>(runtime, box_c_bytes.ptr));
+    obj.setProperty(runtime, "len", static_cast<double>(box_c_bytes.len));
+    return obj;
+  }
 
-using Task = std::function<void(Runtime *)>;
+  using Task = std::function<void(Runtime *)>;
 
-struct {
-  std::mutex mutex;
-  std::vector<Task> tasks;
-  // std::condition_variable condition;
-} TASKS;
+  struct
+  {
+    std::mutex mutex;
+    std::vector<Task> tasks;
+    // std::condition_variable condition;
+  } TASKS;
 
-void ditto_enqueue_call(Task &&task) {
-  std::unique_lock<std::mutex> lock{TASKS.mutex};
-  TASKS.tasks.emplace_back(task);
-  // TASKS.condition.notify_one();
-}
+  void ditto_enqueue_call(Task &&task)
+  {
+    std::unique_lock<std::mutex> lock{TASKS.mutex};
+    TASKS.tasks.emplace_back(task);
+    // TASKS.condition.notify_one();
+  }
 
-Task try_recv_task() {
-  std::unique_lock<std::mutex> lock(TASKS.mutex);
-  // TASKS.condition.wait(lock, [] { return !TASKS.tasks.empty(); });
-  if (TASKS.tasks.empty()) {
-    return nullptr;
+  Task try_recv_task()
+  {
+    std::unique_lock<std::mutex> lock(TASKS.mutex);
+    // TASKS.condition.wait(lock, [] { return !TASKS.tasks.empty(); });
+    if (TASKS.tasks.empty())
+    {
+      return nullptr;
+    }
+    Task task{std::move(TASKS.tasks.back())};
+    TASKS.tasks.pop_back();
+    return task;
   }
-  Task task{std::move(TASKS.tasks.back())};
-  TASKS.tasks.pop_back();
-  return task;
-}
 
-void ditto_tick(Runtime *jsi) {
-  while (1) {
-    Task task = try_recv_task();
-    if (task == nullptr) {
-      return;
-    } else {
-      task(jsi);
+  void ditto_tick(Runtime *jsi)
+  {
+    while (1)
+    {
+      Task task = try_recv_task();
+      if (task == nullptr)
+      {
+        return;
+      }
+      else
+      {
+        task(jsi);
+      }
     }
   }
 }
-}

package/react-native/cpp/src/main.cpp

@@ -16,6 +16,8 @@
 #include "Logger.h"
 #include "SmallPeerInfo.h"
 #include "Transports.h"
+#include "IO.h"
+#include "FFIUtils.h"
 
 // Note: `runtime` variable must exist in scope.
 #define REGISTER_JS_FUNCTION(fname) runtime.global().setProperty(runtime, STRINGIFY(fname), fname(runtime));
@@ -37,11 +39,16 @@ namespace sharedjsi
 
     // Lifecycle
     REGISTER_JS_FUNCTION(ditto_init_sdk_version);
-    REGISTER_JS_FUNCTION(ditto_uninitialized_ditto_make);
     REGISTER_JS_FUNCTION(ditto_make);
     REGISTER_JS_FUNCTION(ditto_shutdown);
     REGISTER_JS_FUNCTION(ditto_free);
 
+    // FFI Utils
+    REGISTER_JS_FUNCTION(refCStringToString);
+    REGISTER_JS_FUNCTION(boxCStringIntoString);
+    REGISTER_JS_FUNCTION(withOutBoxCBytes);
+    REGISTER_JS_FUNCTION(sliceBoxedToUInt8Array);
+
     // Authentication
     REGISTER_JS_FUNCTION(ditto_auth_client_get_app_id);
     REGISTER_JS_FUNCTION(ditto_auth_client_is_x509_valid);
@@ -57,15 +64,15 @@ namespace sharedjsi
 
     // DQL
     REGISTER_JS_FUNCTION(dittoffi_try_experimental_register_change_observer_str_detached);
-    REGISTER_JS_FUNCTION(dittoffi_try_experimental_add_dql_subscription);
-    REGISTER_JS_FUNCTION(dittoffi_try_experimental_remove_dql_subscription);
-    REGISTER_JS_FUNCTION(dittoffi_try_experimental_exec_statement_str);
-    REGISTER_JS_FUNCTION(ditto_dql_response_result_count);
-    REGISTER_JS_FUNCTION(ditto_dql_response_result_at);
-    REGISTER_JS_FUNCTION(ditto_dql_response_affected_document_id_count);
-    REGISTER_JS_FUNCTION(ditto_dql_response_affected_document_id_at);
-    REGISTER_JS_FUNCTION(ditto_result_cbor);
-    REGISTER_JS_FUNCTION(ditto_result_json);
+    REGISTER_JS_FUNCTION(dittoffi_try_add_sync_subscription);
+    REGISTER_JS_FUNCTION(dittoffi_try_remove_sync_subscription);
+    REGISTER_JS_FUNCTION(dittoffi_try_exec_statement);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_item_count);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_item_at);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_mutated_document_id_count);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_mutated_document_id_at);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_item_cbor);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_item_json);
 
     // Documents
     REGISTER_JS_FUNCTION(ditto_document_id_query_compatible);
@@ -80,10 +87,14 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_clear_presence_v3_callback);
 
     // Attachment
+    REGISTER_JS_FUNCTION(ditto_new_attachment_from_file);
+    REGISTER_JS_FUNCTION(ditto_new_attachment_from_bytes);
+    REGISTER_JS_FUNCTION(ditto_resolve_attachment);
     REGISTER_JS_FUNCTION(ditto_cancel_resolve_attachment);
     REGISTER_JS_FUNCTION(ditto_free_attachment_handle);
+    REGISTER_JS_FUNCTION(ditto_get_attachment_status);
+    REGISTER_JS_FUNCTION(ditto_get_complete_attachment_data);
     REGISTER_JS_FUNCTION(ditto_get_complete_attachment_path);
-    REGISTER_JS_FUNCTION(ditto_new_attachment_from_bytes);
 
     // LiveQuery
     REGISTER_JS_FUNCTION(ditto_live_query_start);
@@ -112,10 +123,6 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_small_peer_info_get_metadata);
     REGISTER_JS_FUNCTION(ditto_small_peer_info_set_metadata);
 
-    // FFI functions
-    REGISTER_JS_FUNCTION(withOutBoxCBytes);
-    REGISTER_JS_FUNCTION(sliceBoxedToUInt8Array);
-
     // Transports
     REGISTER_JS_FUNCTION(ditto_sdk_transports_init);
     REGISTER_JS_FUNCTION(ditto_sdk_transports_error_new);
@@ -148,5 +155,11 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_set_static_websocket_clients);
     REGISTER_JS_FUNCTION(ditto_set_sync_group);
     REGISTER_JS_FUNCTION(refCStringToString);
+    REGISTER_JS_FUNCTION(ditto_disable_sync_with_v3);
+    REGISTER_JS_FUNCTION(dittoffi_base64_encode);
+    REGISTER_JS_FUNCTION(dittoffi_try_base64_decode);
+
+    // IO
+    REGISTER_JS_FUNCTION(readFile);
   }
 }