@dittolive/ditto 4.10.2 → 4.11.0-preview.1

package/react-native/cpp/include/DQL.h

@@ -18,6 +18,7 @@ Function dittoffi_query_result_item_cbor(Runtime &runtime);
 Function dittoffi_query_result_item_json(Runtime &runtime);
 Function dittoffi_query_result_free(Runtime &runtime);
 Function dittoffi_query_result_item_free(Runtime &runtime);
+Function dittoffi_query_result_item_new(Runtime &runtime);
 }
 
 #endif /* DQL_H */

package/react-native/cpp/include/Differ.h

@@ -0,0 +1,14 @@
+#ifndef DIFFER_H
+#define DIFFER_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi {
+Function dittoffi_differ_new(Runtime &runtime);
+Function dittoffi_differ_diff(Runtime &runtime);
+Function dittoffi_differ_free(Runtime &runtime);
+}
+
+#endif /* DIFFER_H */

package/react-native/cpp/include/Lifecycle.h

@@ -10,7 +10,7 @@ namespace sharedjsi
 Function ditto_init_sdk_version(Runtime &runtime);
 Function ditto_shutdown(Runtime &runtime);
 Function ditto_free(Runtime &runtime);
-Function dittoffi_make_with_transport_config_mode(Runtime &runtime);
+Function dittoffi_ditto_try_new_blocking(Runtime &runtime);
 }
 
 #endif /* Lifecycle_H */

package/react-native/cpp/include/Transaction.h

@@ -0,0 +1,18 @@
+#ifndef Transaction_H
+#define Transaction_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function dittoffi_store_transactions(Runtime &runtime);
+Function dittoffi_store_begin_transaction_async_throws(Runtime &runtime);
+Function dittoffi_transaction_complete_async_throws(Runtime &runtime);
+Function dittoffi_transaction_execute_async_throws(Runtime &runtime);
+Function dittoffi_transaction_info(Runtime &runtime);
+Function dittoffi_transaction_free(Runtime &runtime);
+}
+
+#endif /* Transaction_H */

package/react-native/cpp/include/Transports.h

@@ -13,5 +13,6 @@ Function ditto_sdk_transports_error_free(Runtime &runtime);
 Function dittoffi_ditto_try_set_transport_config(Runtime &runtime);
 Function dittoffi_ditto_transport_config(Runtime &runtime);
 Function dittoffi_ditto_set_cloud_sync_enabled(Runtime &runtime);
+Function ditto_register_transport_condition_changed_callback(Runtime &runtime);
 }
 #endif /* Transports_h */

package/react-native/cpp/include/Utils.h

@@ -43,6 +43,32 @@ T *jsPointerObjectToCPointer(Runtime &runtime, const Value &arg)
   return ptr;
 }
 
+template <typename T>
+std::vector<T> jsPointerArrayToVector(jsi::Runtime &runtime,
+                                    const jsi::Value &arg) {
+  if (arg.isUndefined() || arg.isNull()) {
+    return {};
+  }
+  if (!arg.isObject() || !arg.asObject(runtime).isArray(runtime)) {
+    throw std::invalid_argument("Expected a JavaScript array");
+  }
+
+  jsi::Array jsArray = arg.asObject(runtime).asArray(runtime);
+  std::vector<T> res;
+  res.reserve(jsArray.length(runtime));
+
+  for (size_t i = 0; i < jsArray.length(runtime); ++i) {
+    const jsi::Value &val = jsArray.getValueAtIndex(runtime, i);
+    res.push_back(
+        jsPointerObjectToCPointer<typename std::remove_pointer<T>::type>(
+            runtime, val));
+  }
+  return res;
+}
+
+std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg);
+std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg);
+
 template<typename T>
 Object cSlicedBoxToJSSlicedBox(Runtime &runtime, T box_c_bytes)
 {
@@ -52,11 +78,9 @@ Object cSlicedBoxToJSSlicedBox(Runtime &runtime, T box_c_bytes)
   return obj;
 }
 
-std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg);
-std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg);
-
 slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const& v);
 slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const& v);
+slice_ref_dittoffi_query_result_item_ptr borrowVecAsRefSlice(std::vector<dittoffi_query_result_item_t *> const& v);
 
 Value int64ToBigIntOrNumber(Runtime &runtime, int64_t value);
 Value uint64ToBigIntOrNumber(Runtime &runtime, uint64_t value);

package/react-native/cpp/include/main.h

@@ -2,6 +2,8 @@
 #define MAIN_H
 
 #include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
 using namespace facebook::jsi;
 
 namespace sharedjsi

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

@@ -281,4 +281,25 @@ Function dittoffi_query_result_item_free(Runtime &runtime)
   });
 }
 
+Function dittoffi_query_result_item_new(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
+                                          {
+                                            std::vector<uint8_t> jsonVec = jsTypedArrayToCVector(runtime, arguments[0]);
+                                            slice_ref_uint8_t jsonSlice = borrowVecAsRefSlice(jsonVec);
+                                            auto res = ::dittoffi_query_result_item_new(jsonSlice);
+
+                                            Object out(runtime);
+                                            out.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+                                            out.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+                                            return out;
+                                          });
+}
 }

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

@@ -0,0 +1,57 @@
+#include <Differ.h>
+#include "Utils.h"
+
+namespace sharedjsi
+{
+
+Function dittoffi_differ_new(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 {
+                                               dittoffi_differ_t *ffiDiffer = ::dittoffi_differ_new();
+                                               return cPointerToJSPointerObject<dittoffi_differ_t>(runtime, ffiDiffer);
+                                             });
+}
+
+Function dittoffi_differ_free(Runtime &runtime)
+{
+  return Function::createFromHostFunction(
+                                          runtime,
+                                          PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
+                                          1,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value {
+                                               dittoffi_differ_t *ffiDiffer = jsPointerObjectToCPointer<dittoffi_differ_t>(runtime, arguments[0]);
+                                               ::dittoffi_differ_free(ffiDiffer);
+                                               return {};
+                                             });
+}
+
+Function dittoffi_differ_diff(Runtime &runtime)
+{
+  return Function::createFromHostFunction(
+                                          runtime,
+                                          PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
+                                          2,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value {
+                                               dittoffi_differ_t *ffiDiffer = jsPointerObjectToCPointer<dittoffi_differ_t>(runtime, arguments[0]);
+
+                                               auto items_vec = jsPointerArrayToVector<dittoffi_query_result_item_t *>(runtime, arguments[1]);
+                                               slice_ref_dittoffi_query_result_item_ptr items = borrowVecAsRefSlice(items_vec);
+                                               
+                                               auto cborBlob = ::dittoffi_differ_diff(ffiDiffer, items);
+                                               return cSlicedBoxToJSSlicedBox(runtime, cborBlob);
+                                             });
+}
+}

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

@@ -36,7 +36,7 @@ Function ditto_free(Runtime &runtime)
   });
 }
 
-Function dittoffi_make_with_transport_config_mode(Runtime &runtime)
+Function dittoffi_ditto_try_new_blocking(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -50,7 +50,8 @@ Function dittoffi_make_with_transport_config_mode(Runtime &runtime)
     std::string path = jsTypedArrayToCString(runtime, arguments[0]);
     auto *identity_config = jsPointerObjectToCPointer<CIdentityConfig_t>(runtime, arguments[1]);
     std::string history_tracking_str = arguments[2].toString(runtime).utf8(runtime);
-    std::string transport_mode_str = arguments[3].toString(runtime).utf8(runtime);
+    std::string experimental_passphrase = jsTypedArrayToCString(runtime, arguments[3]);
+    std::string transport_config_mode_str = arguments[4].toString(runtime).utf8(runtime);
 
     HistoryTracking_t history_tracking;
     if (history_tracking_str == "Disabled") {
@@ -60,18 +61,27 @@ Function dittoffi_make_with_transport_config_mode(Runtime &runtime)
     } else {
         throw std::invalid_argument("Invalid history tracking mode provided");
     }
-    
+
     TransportConfigMode_t transport_config_mode;
-    if (transport_mode_str == "PlatformDependent") {
+    if (transport_config_mode_str == "PlatformDependent") {
         transport_config_mode = TRANSPORT_CONFIG_MODE_PLATFORM_DEPENDENT;
-    } else if (transport_mode_str == "PlatformIndependent") {
+    } else if (transport_config_mode_str == "PlatformIndependent") {
         transport_config_mode = TRANSPORT_CONFIG_MODE_PLATFORM_INDEPENDENT;
     } else {
         throw std::invalid_argument("Invalid transport configuration mode provided");
     }
 
-    CDitto_t *pointer = ::dittoffi_make_with_transport_config_mode(path.c_str(), identity_config, history_tracking, transport_config_mode);
-    return cPointerToJSPointerObject(runtime, pointer);
+    dittoffi_result_CDitto_ptr_t res = ::dittoffi_ditto_try_new_blocking(
+        path.c_str(),
+        identity_config,
+        history_tracking,
+        experimental_passphrase.empty() ? nullptr: experimental_passphrase.c_str(),
+        transport_config_mode
+    );
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
   });
 }
 

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

@@ -51,6 +51,55 @@ Function ditto_error_message(Runtime &runtime) {
   });
 }
 
+String getErrorCodeString(jsi::Runtime &runtime, dittoffi_error_code_t error_code) {
+  const std::string name = [&]() -> std::string {
+    switch (error_code) {
+      case DITTOFFI_ERROR_CODE_STORE_DOCUMENT_NOT_FOUND: return "StoreDocumentNotFound";
+      case DITTOFFI_ERROR_CODE_STORE_DATABASE: return "StoreDatabase";
+      case DITTOFFI_ERROR_CODE_STORE_QUERY: return "StoreQuery";
+      case DITTOFFI_ERROR_CODE_CRDT: return "Crdt";
+      case DITTOFFI_ERROR_CODE_UNKNOWN: return "Unknown";
+      case DITTOFFI_ERROR_CODE_BASE64_INVALID: return "Base64Invalid";
+      case DITTOFFI_ERROR_CODE_CBOR_UNSUPPORTED: return "CborUnsupported";
+      case DITTOFFI_ERROR_CODE_JS_FLOATING_STORE_OPERATION: return "JsFloatingStoreOperation";
+      case DITTOFFI_ERROR_CODE_DQL_QUERY_COMPILATION: return "DqlQueryCompilation";
+      case DITTOFFI_ERROR_CODE_DQL_INVALID_QUERY_ARGS: return "DqlInvalidQueryArgs";
+      case DITTOFFI_ERROR_CODE_DQL_UNSUPPORTED: return "DqlUnsupported";
+      case DITTOFFI_ERROR_CODE_DQL_EVALUATION_ERROR: return "DqlEvaluationError";
+      case DITTOFFI_ERROR_CODE_PARAMETER_QUERY: return "ParameterQuery";
+      case DITTOFFI_ERROR_CODE_VALIDATION_DEPTH_LIMIT_EXCEEDED: return "ValidationDepthLimitExceeded";
+      case DITTOFFI_ERROR_CODE_VALIDATION_NOT_A_MAP: return "ValidationNotAMap";
+      case DITTOFFI_ERROR_CODE_VALIDATION_SIZE_LIMIT_EXCEEDED: return "ValidationSizeLimitExceeded";
+      case DITTOFFI_ERROR_CODE_CBOR_INVALID:
+      case DITTOFFI_ERROR_CODE_VALIDATION_INVALID_CBOR: return "ValidationInvalidCbor";
+      case DITTOFFI_ERROR_CODE_VALIDATION_INVALID_JSON: return "ValidationInvalidJson";
+      case DITTOFFI_ERROR_CODE_ACTIVATION_NOT_ACTIVATED: return "ActivationNotActivated";
+      case DITTOFFI_ERROR_CODE_VALIDATION_INVALID_TRANSPORT_CONFIG: return "ValidationInvalidTransportConfig";
+      case DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_TOKEN_INVALID: return "ActivationLicenseTokenInvalid";
+      case DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_TOKEN_EXPIRED: return "ActivationLicenseTokenExpired";
+      case DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_UNSUPPORTED_FUTURE_VERSION: return "ActivationLicenseUnsupportedFutureVersion";
+      case DITTOFFI_ERROR_CODE_ACTIVATION_UNNECESSARY: return "ActivationUnnecessary";
+      case DITTOFFI_ERROR_CODE_IO_NOT_FOUND: return "IoNotFound";
+      case DITTOFFI_ERROR_CODE_IO_PERMISSION_DENIED: return "IoPermissionDenied";
+      case DITTOFFI_ERROR_CODE_IO_ALREADY_EXISTS: return "IoAlreadyExists";
+      case DITTOFFI_ERROR_CODE_IO_OPERATION_FAILED: return "IoOperationFailed";
+      case DITTOFFI_ERROR_CODE_UNSUPPORTED: return "Unsupported";
+      case DITTOFFI_ERROR_CODE_TRANSPORT: return "Transport";
+      case DITTOFFI_ERROR_CODE_LOCKED_DITTO_WORKING_DIRECTORY: return "LockedDittoWorkingDirectory";
+      case DITTOFFI_ERROR_CODE_ENCRYPTION_EXTRANEOUS_PASSPHRASE_GIVEN: return "EncryptionExtraneousPassphraseGiven";
+      case DITTOFFI_ERROR_CODE_ENCRYPTION_PASSPHRASE_INVALID: return "EncryptionPassphraseInvalid";
+      case DITTOFFI_ERROR_CODE_ENCRYPTION_PASSPHRASE_NOT_GIVEN: return "EncryptionPassphraseNotGiven";
+      case DITTOFFI_ERROR_CODE_STORE_DOCUMENT_ID: return "StoreDocumentId";
+      case DITTOFFI_ERROR_CODE_STORE_TRANSACTION_READ_ONLY: return "TransactionReadOnly";
+      case DITTOFFI_ERROR_CODE_INTERNAL: return "Internal";
+    }
+
+    throw std::invalid_argument("Unknown error code.");
+  }();
+
+  return String::createFromUtf8(runtime, name);
+}
+
 Function dittoffi_error_code(Runtime &runtime) {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -63,38 +112,7 @@ Function dittoffi_error_code(Runtime &runtime) {
                                           {
     auto *error = jsPointerObjectToCPointer<dittoffi_error_t>(runtime, arguments[0]);
     dittoffi_error_code_t error_code = ::dittoffi_error_code(error);
-
-    static const std::unordered_map<dittoffi_error_code_t, std::string> lookup = {
-      {DITTOFFI_ERROR_CODE_STORE_DOCUMENT_NOT_FOUND, "StoreDocumentNotFound"},
-      {DITTOFFI_ERROR_CODE_STORE_DATABASE, "StoreDatabase"},
-      {DITTOFFI_ERROR_CODE_STORE_QUERY, "StoreQuery"},
-      {DITTOFFI_ERROR_CODE_CRDT, "Crdt"},
-      {DITTOFFI_ERROR_CODE_JS_FLOATING_STORE_OPERATION, "JsFloatingStoreOperation"},
-      {DITTOFFI_ERROR_CODE_DQL_QUERY_COMPILATION, "DqlQueryCompilation"},
-      {DITTOFFI_ERROR_CODE_DQL_INVALID_QUERY_ARGS, "DqlInvalidQueryArgs"},
-      {DITTOFFI_ERROR_CODE_DQL_UNSUPPORTED, "DqlUnsupported"},
-      {DITTOFFI_ERROR_CODE_VALIDATION_DEPTH_LIMIT_EXCEEDED, "ValidationDepthLimitExceeded"},
-      {DITTOFFI_ERROR_CODE_VALIDATION_NOT_A_MAP, "ValidationNotAMap"},
-      {DITTOFFI_ERROR_CODE_VALIDATION_SIZE_LIMIT_EXCEEDED, "ValidationSizeLimitExceeded"},
-      {DITTOFFI_ERROR_CODE_CBOR_INVALID, "ValidationInvalidCbor"},
-      {DITTOFFI_ERROR_CODE_VALIDATION_INVALID_JSON, "ValidationInvalidJson"},
-      {DITTOFFI_ERROR_CODE_ACTIVATION_NOT_ACTIVATED, "ActivationNotActivated"},
-      {DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_TOKEN_INVALID, "ActivationLicenseTokenInvalid"},
-      {DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_TOKEN_EXPIRED, "ActivationLicenseTokenExpired"},
-      {DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_UNSUPPORTED_FUTURE_VERSION, "ActivationLicenseUnsupportedFutureVersion"},
-      {DITTOFFI_ERROR_CODE_IO_NOT_FOUND, "IoNotFound"},
-      {DITTOFFI_ERROR_CODE_IO_PERMISSION_DENIED, "IoPermissionDenied"},
-      {DITTOFFI_ERROR_CODE_IO_ALREADY_EXISTS, "IoAlreadyExists"},
-      {DITTOFFI_ERROR_CODE_IO_OPERATION_FAILED, "IoOperationFailed"},
-      {DITTOFFI_ERROR_CODE_UNSUPPORTED, "Unsupported"}
-    };
-
-    auto it = lookup.find(error_code);
-    if (it != lookup.end()) {
-      return String::createFromUtf8(runtime, it->second);
-    } else {
-      throw std::invalid_argument("Unknown error code.");
-    }
+    return getErrorCodeString(runtime, error_code);
   });
 }
 

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

@@ -0,0 +1,195 @@
+#include "Utils.h"
+#include "Arc.hpp"
+
+#include <Misc.h>
+
+namespace sharedjsi
+{
+
+/* Post-condition: refcount -= 1; dtor untouched. */
+static void v_release(void *ptr) {
+  Arc<Function>::from_raw(ptr);
+}
+
+extern "C"
+{
+void v_transaction_result(void *ctx, dittoffi_result_dittoffi_transaction_ptr_t res)
+{
+  Arc<Function> const& borrowedJsCallback = Arc<Function>::borrow_from_raw(ctx);
+  // copy ctor / retain so as to keep the ArcPointee<Function> alive until the enqueued_call completes.
+  jsi_enqueue_call([=, jsCallback=Arc<Function>(borrowedJsCallback)](Runtime &runtime) {
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    jsCallback->call(runtime, obj);
+  });
+}
+
+void v_transaction_completion_action_result(void *ctx, dittoffi_result_dittoffi_transaction_completion_action_t res)
+{
+  Arc<Function> const& borrowedJsCallback = Arc<Function>::borrow_from_raw(ctx);
+  // copy ctor / retain so as to keep the ArcPointee<Function> alive until the enqueued_call completes.
+  jsi_enqueue_call([=, jsCallback=Arc<Function>(borrowedJsCallback)](Runtime &runtime) {
+    std::string action;
+    switch (res.success) {
+      case DITTOFFI_TRANSACTION_COMPLETION_ACTION_COMMIT:
+        action = "Commit";
+        break ;
+      case DITTOFFI_TRANSACTION_COMPLETION_ACTION_ROLLBACK:
+        action = "Rollback";
+        break;
+    }
+    
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", action);
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    jsCallback->call(runtime, obj);
+  });
+}
+
+void v_transaction_query_result(void *ctx, dittoffi_result_dittoffi_query_result_ptr_t res)
+{
+  Arc<Function> const& borrowedJsCallback = Arc<Function>::borrow_from_raw(ctx);
+  // copy ctor / retain so as to keep the ArcPointee<Function> alive until the enqueued_call completes.
+  jsi_enqueue_call([=, jsCallback=Arc<Function>(borrowedJsCallback)](Runtime &runtime) {
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    jsCallback->call(runtime, obj);
+  });
+}
+
+}
+
+Function dittoffi_store_transactions(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 {
+    dittoffi_cbor_data_t res = ::dittoffi_store_transactions(jsPointerObjectToCPointer<dittoffi_store_t>(runtime, arguments[0]));
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function dittoffi_store_begin_transaction_async_throws(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 *store = jsPointerObjectToCPointer<dittoffi_store_t>(runtime, arguments[0]);
+    auto optionsObj = arguments[1].asObject(runtime);
+    Function callback = arguments[2].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(callback));
+    
+    dittoffi_store_begin_transaction_options_t options = {0};
+    
+    if (optionsObj.getProperty(runtime, "is_read_only").isBool()) {
+      options.is_read_only = optionsObj.getProperty(runtime, "is_read_only").asBool();
+    }
+    
+    std::string hint_str;
+    if (!optionsObj.getProperty(runtime, "hint").isNull()) {
+      hint_str = jsTypedArrayToCString(runtime, optionsObj.getProperty(runtime, "hint"));
+      options.hint = hint_str.c_str();
+    }
+    
+    ::dittoffi_store_begin_transaction_async_throws(store, options, {
+      .env_ptr = Arc<Function>::into_raw(std::move(wrappedStateFfiWrapper)),
+      .call = v_transaction_result,
+      .free = v_release,
+    });
+    return Value();
+  });
+}
+
+Function dittoffi_transaction_complete_async_throws(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 *transaction = jsPointerObjectToCPointer<dittoffi_transaction_t>(runtime, arguments[0]);
+    std::string action_str = arguments[1].asString(runtime).utf8(runtime);
+    Function callback = arguments[2].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(callback));
+    
+    dittoffi_transaction_completion_action_t action;
+    if (action_str == "Commit") {
+      action = DITTOFFI_TRANSACTION_COMPLETION_ACTION_COMMIT;
+    } else if (action_str == "Rollback") {
+      action = DITTOFFI_TRANSACTION_COMPLETION_ACTION_ROLLBACK;
+    } else {
+      throw "Invalid transaction completing action provided.";
+    }
+    
+    ::dittoffi_transaction_complete_async_throws(transaction, action, {
+      .env_ptr = Arc<Function>::into_raw(std::move(wrappedStateFfiWrapper)),
+      .call = v_transaction_completion_action_result,
+      .free = v_release,
+    });
+    return Value();
+  });
+}
+
+Function dittoffi_transaction_execute_async_throws(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 *transaction = jsPointerObjectToCPointer<dittoffi_transaction_t>(runtime, arguments[0]);
+    std::string query_str = jsTypedArrayToCString(runtime, arguments[1]);
+    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
+    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
+    Function callback = arguments[3].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(callback));
+    
+    ::dittoffi_transaction_execute_async_throws(transaction, query_str.c_str(), query_args_cbor, {
+      .env_ptr = Arc<Function>::into_raw(std::move(wrappedStateFfiWrapper)),
+      .call = v_transaction_query_result,
+      .free = v_release,
+    });
+    return Value();
+  });
+}
+
+Function dittoffi_transaction_info(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 {
+  
+    
+    dittoffi_cbor_data_t res = ::dittoffi_transaction_info(jsPointerObjectToCPointer<dittoffi_transaction_t>(runtime, arguments[0]));
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function dittoffi_transaction_free(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 {
+  
+    
+    ::dittoffi_transaction_free(jsPointerObjectToCPointer<dittoffi_transaction_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+}

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

@@ -1,10 +1,66 @@
 #include "Utils.h"
-
+#include "Arc.hpp"
 #include <Transports.h>
+#include <map>
 
 namespace sharedjsi
 {
 
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
+
+extern "C" {
+void v_transport_condition_change_cb(void *ctx, ConditionSource_t condition_source, TransportCondition_t transport_condition)
+{
+  Arc<Function> const& borrowedJsCallback = Arc<Function>::borrow_from_raw(ctx);
+  // copy ctor / retain so as to keep the ArcPointee<Function> alive until the enqueued_call completes.
+  Arc<Function> jsCallback /* = */ (borrowedJsCallback);
+  jsi_enqueue_call([=](Runtime &runtime) {
+    const std::map<ConditionSource_t, std::string> conditionSourceToString = {
+      {CONDITION_SOURCE_BLUETOOTH, "Bluetooth"},
+      {CONDITION_SOURCE_TCP, "Tcp"},
+      {CONDITION_SOURCE_AWDL, "Awdl"},
+      {CONDITION_SOURCE_MDNS, "Mdns"},
+      {CONDITION_SOURCE_WIFI_AWARE, "WiFiAware"}
+    };
+    
+    
+    std::string condition_source_str;
+    auto it = conditionSourceToString.find(condition_source);
+    if (it != conditionSourceToString.end()) {
+      condition_source_str = it->second;
+    } else {
+      throw std::invalid_argument("Invalid ConditionSource_t value. A new value might've been introduced that is not handled.");
+    }
+    
+    std::string transport_condition_str;
+    const std::unordered_map<TransportCondition_t, std::string> transportConditionMap = {
+      {TRANSPORT_CONDITION_UNKNOWN, "Unknown"},
+      {TRANSPORT_CONDITION_OK, "Ok"},
+      {TRANSPORT_CONDITION_GENERIC_FAILURE, "GenericFailure"},
+      {TRANSPORT_CONDITION_APP_IN_BACKGROUND, "AppInBackground"},
+      {TRANSPORT_CONDITION_MDNS_FAILURE, "MDNSFailure"},
+      {TRANSPORT_CONDITION_TCP_LISTEN_FAILURE, "TCPListenFailure"},
+      {TRANSPORT_CONDITION_NO_BLE_CENTRAL_PERMISSION, "NoBLECentralPermission"},
+      {TRANSPORT_CONDITION_NO_BLE_PERIPHERAL_PERMISSION, "NoBLEPeripheralPermission"},
+      {TRANSPORT_CONDITION_CANNOT_ESTABLISH_CONNECTION, "CannotEstablishConnection"},
+      {TRANSPORT_CONDITION_BLE_DISABLED, "BLEDisabled"},
+      {TRANSPORT_CONDITION_NO_BLE_HARDWARE, "NoBLEHardware"},
+      {TRANSPORT_CONDITION_WIFI_DISABLED, "WiFiDisabled"},
+      {TRANSPORT_CONDITION_TEMPORARILY_UNAVAILABLE, "TemporarilyUnavailable"},
+    };
+    
+    auto it2 = transportConditionMap.find(transport_condition);
+    if (it2 != transportConditionMap.end()) {
+      transport_condition_str = it2->second;
+    } else {
+      throw std::invalid_argument("Invalid TransportCondition_t value. A new value might've been introduced that is not handled.");
+    }
+    
+    jsCallback->call(runtime, condition_source_str, transport_condition_str);
+  });
+}
+}
+
 Function ditto_sdk_transports_error_new(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
@@ -145,4 +201,24 @@ Function dittoffi_ditto_set_cloud_sync_enabled(Runtime &runtime)
     return {};
   });
 }
+
+Function ditto_register_transport_condition_changed_callback(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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    Function jsCallback = arguments[1].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(jsCallback));
+    
+    ::ditto_register_transport_condition_changed_callback(ditto, Arc<Function>::as_raw(wrappedStateFfiWrapper), v_retain, v_release, v_transport_condition_change_cb);
+    return {};
+  });
+}
 }

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

@@ -32,6 +32,17 @@ slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const &v)
   return it;
 }
 
+slice_ref_dittoffi_query_result_item_ptr
+borrowVecAsRefSlice(std::vector<dittoffi_query_result_item_t *> const &vector)
+{
+    slice_ref_dittoffi_query_result_item_ptr slice{};
+    slice.ptr = vector.empty()
+                ? reinterpret_cast<dittoffi_query_result_item_t **>(0xbad000)
+                : const_cast<dittoffi_query_result_item_t **>(vector.data());
+    slice.len = vector.size();
+    return slice;
+}
+
 std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg)
 {
   if (arg.isUndefined() || arg.isNull())