@dittolive/ditto 4.11.2-rc.1 → 4.12.0-experimental-untangle.0

package/react-native/android/dittoffi/src/dittostore_java.i

@@ -46,6 +46,7 @@
             ptr = obj.swigCPtr;
             obj.swigCMemOwn = false;
             obj.delete();
+            obj.swigCPtr = 0;
         }
         return ptr;
     }

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

@@ -19,6 +19,8 @@ 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);
+Function dittoffi_query_result_has_commit_id(Runtime &runtime);
+Function dittoffi_query_result_commit_id(Runtime &runtime);
 }
 
 #endif /* DQL_H */

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

@@ -10,6 +10,8 @@ namespace sharedjsi
 Function readFile(Runtime &runtime);
 Function copyFile(Runtime &runtime);
 Function createDirectory(Runtime &runtime, String &defaultDirPath);
+Function getDefaultDirectory(Runtime &runtime, String &defaultDirPath);
+Function dittoffi_ditto_absolute_persistence_directory(Runtime &runtime);
 }
 
 #endif /* IO_H */

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

@@ -11,6 +11,13 @@ Function ditto_init_sdk_version(Runtime &runtime);
 Function ditto_shutdown(Runtime &runtime);
 Function ditto_free(Runtime &runtime);
 Function dittoffi_ditto_try_new_blocking(Runtime &runtime);
+Function dittoffi_ditto_open_throws(Runtime &runtime);
+Function dittoffi_DEFAULT_DATABASE_ID(Runtime &runtime);
+Function dittoffi_DITTO_DEVELOPMENT_PROVIDER(Runtime &runtime);
+Function dittoffi_ditto_config_default(Runtime &runtime);
+Function dittoffi_ditto_config(Runtime &runtime);
+Function dittoffi_ditto_transport_config(Runtime &runtime);
+Function dittoffi_ditto_open_async_throws(Runtime &runtime);
 }
 
 #endif /* Lifecycle_H */

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #if defined(__APPLE__)
-#include "DittoReactNative/dittoffi.h"
+#include "DittoCore/dittoffi.h"
 #elif defined(__ANDROID__)
 #include <dittoffi.h>
 #else

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

@@ -47,7 +47,11 @@ Function dittoffi_try_add_sync_subscription(Runtime &runtime)
     dittoffi_result_void_t res = ::dittoffi_try_add_sync_subscription(ditto, query, query_args_cbor);
 
     Object obj(runtime);
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }
@@ -72,7 +76,11 @@ Function dittoffi_try_remove_sync_subscription(Runtime &runtime)
     dittoffi_result_void_t res = ::dittoffi_try_remove_sync_subscription(ditto, query, query_args_cbor);
 
     Object obj(runtime);
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }
@@ -98,7 +106,11 @@ Function dittoffi_try_exec_statement(Runtime &runtime)
 
     Object obj(runtime);
     obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }
@@ -145,7 +157,11 @@ Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime
 
     Object obj(runtime);
     obj.setProperty(runtime, "success", int64ToBigIntOrNumber(runtime, res.success));
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }
@@ -302,4 +318,34 @@ Function dittoffi_query_result_item_new(Runtime &runtime)
                                             return out;
                                           });
 }
+
+Function dittoffi_query_result_has_commit_id(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
+                                          {
+    bool res = ::dittoffi_query_result_has_commit_id(jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]));
+    return res;
+  });
+}
+
+Function dittoffi_query_result_commit_id(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
+                                          {
+    uint64_t res = ::dittoffi_query_result_commit_id(jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]));
+    return uint64ToBigIntOrNumber(runtime, res);
+  });
+}
 }

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

@@ -111,4 +111,44 @@ Function createDirectory(Runtime &runtime, String &defaultDirPath)
     return String::createFromUtf8(runtime, finalPath);
   });
 }
+
+Function dittoffi_ditto_absolute_persistence_directory(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
+                                          {
+    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    char* absolute_path = ::dittoffi_ditto_absolute_persistence_directory(ditto);
+    return cPointerToJSPointerObject<char>(runtime, absolute_path);
+
+  });
+}
+
+Function getDefaultDirectory(Runtime &runtime, String &defaultDirPath)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          1,
+                                          [defaultDirPathStr = defaultDirPath.utf8(runtime)](Runtime &runtime,
+                                                                                             const Value &thisValue,
+                                                                                             const Value *arguments,
+                                                                                             size_t count) -> Value
+                                          {
+    std::string path = arguments[0].asString(runtime).utf8(runtime);
+
+    std::string finalPath = path;
+    if (path.empty() || path[0] != '/') {
+      finalPath = defaultDirPathStr + "/" + path;
+    }
+
+    return String::createFromUtf8(runtime, finalPath);
+  });
+}
 }

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

@@ -1,9 +1,13 @@
 #include "Utils.h"
+#include "Arc.hpp"
 
 #include <Lifecycle.h>
 
 namespace sharedjsi
 {
+
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
+
 Function ditto_shutdown(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
@@ -108,10 +112,12 @@ Function ditto_init_sdk_version(Runtime &runtime)
     }
 
     Platform_t platform = PLATFORM_UNKNOWN;
-    if (platform_str == "Ios") {
+    if (platform_str == "iOS") {
       platform = PLATFORM_IOS;
     } else if (platform_str == "Android") {
       platform = PLATFORM_ANDROID;
+    } else if (platform_str == "macOS") {
+      platform = PLATFORM_MAC;
     }
 
     ::ditto_init_sdk_version(platform, language, semver);
@@ -119,4 +125,178 @@ Function ditto_init_sdk_version(Runtime &runtime)
   });
 }
 
+Function dittoffi_ditto_open_throws(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          3,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    std::vector<uint8_t> config_cbor_vec = jsTypedArrayToCVector(runtime, arguments[0]);
+    slice_ref_uint8_t config_slice = borrowVecAsRefSlice(config_cbor_vec);
+
+    std::string transport_config_mode_str = arguments[1].toString(runtime).utf8(runtime);
+    
+    TransportConfigMode_t transport_config_mode;
+    if (transport_config_mode_str == "PlatformDependent") {
+        transport_config_mode = TRANSPORT_CONFIG_MODE_PLATFORM_DEPENDENT;
+    } else if (transport_config_mode_str == "PlatformIndependent") {
+        transport_config_mode = TRANSPORT_CONFIG_MODE_PLATFORM_INDEPENDENT;
+    } else {
+        throw std::invalid_argument("Invalid transport configuration mode: " + transport_config_mode_str);
+    }
+
+    std::string default_root_dir_str = jsTypedArrayToCString(runtime, arguments[2]);
+    const char* default_root_directory = default_root_dir_str.c_str();
+
+    dittoffi_result_CDitto_ptr_t res = ::dittoffi_ditto_open_throws(
+        config_slice,
+        transport_config_mode,
+        default_root_directory
+    );
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+Function dittoffi_DEFAULT_DATABASE_ID(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
+                                          {
+    const char* default_id = ::dittoffi_DEFAULT_DATABASE_ID();
+    return cPointerToJSPointerObject<char>(runtime, default_id);
+  });
+}
+
+Function dittoffi_DITTO_DEVELOPMENT_PROVIDER(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
+                                          {
+    const char* dev_provider = ::dittoffi_DITTO_DEVELOPMENT_PROVIDER();
+    return cPointerToJSPointerObject<char>(runtime, dev_provider);
+  });
+}
+
+Function dittoffi_ditto_config_default(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
+                                          {
+    slice_boxed_uint8_t config_cbor = ::dittoffi_ditto_config_default();
+    return cSlicedBoxToJSSlicedBox(runtime, config_cbor);
+  });
+}
+
+Function dittoffi_ditto_config(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
+                                          {
+    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    slice_boxed_uint8_t config_cbor = ::dittoffi_ditto_config(ditto);
+    return cSlicedBoxToJSSlicedBox(runtime, config_cbor);
+  });
+}
+
+
+extern "C"
+{
+void v_ditto_open_result(void *ctx, dittoffi_result_CDitto_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.
+  Arc<Function> jsCallback(borrowedJsCallback);
+  jsi_enqueue_call([=](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_ditto_open_async_throws(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          4,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    // Extract CBOR config from TypedArray using JSI helper
+    std::vector<uint8_t> config_cbor_vec = jsTypedArrayToCVector(runtime, arguments[0]);
+    slice_ref_uint8_t config_slice = borrowVecAsRefSlice(config_cbor_vec);
+
+    // Extract transport config mode
+    std::string transport_config_mode_str = arguments[1].toString(runtime).utf8(runtime);
+    
+    TransportConfigMode_t transport_config_mode;
+    if (transport_config_mode_str == "PlatformDependent") {
+        transport_config_mode = TRANSPORT_CONFIG_MODE_PLATFORM_DEPENDENT;
+    } else if (transport_config_mode_str == "PlatformIndependent") {
+        transport_config_mode = TRANSPORT_CONFIG_MODE_PLATFORM_INDEPENDENT;
+    } else {
+        throw std::invalid_argument("Invalid transport configuration mode: " + transport_config_mode_str);
+    }
+
+    std::string default_root_dir_str = jsTypedArrayToCString(runtime, arguments[2]);
+    const char* default_root_directory = default_root_dir_str.c_str();
+
+    // Extract callback
+    Function callback = arguments[3].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(callback));
+
+    // Call the async FFI function
+    ::dittoffi_ditto_open_async_throws(
+        config_slice,
+        transport_config_mode,
+        default_root_directory,
+        {
+          .env_ptr = Arc<Function>::into_raw(std::move(wrappedStateFfiWrapper)),
+          .call = v_ditto_open_result,
+          .free = v_release,
+        }
+    );
+
+    return Value();
+  });
+}
+
+
 }

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

@@ -8,7 +8,7 @@ namespace sharedjsi
 {
 
 extern "C" {
-void v_call(void *ctx, dittoffi_result_uint64 res)
+void v_call(void *ctx, dittoffi_result_uint64_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.

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

@@ -75,6 +75,9 @@ String getErrorCodeString(jsi::Runtime &runtime, dittoffi_error_code_t error_cod
       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_AUTHENTICATION_EXPIRATION_HANDLER_MISSING: return "AuthenticationExpirationHandlerMissing";
+      case DITTOFFI_ERROR_CODE_DIFFER_IDENTITY_KEY_PATH_INVALID: return "DifferIdentityKeyPathInvalid";
+      case DITTOFFI_ERROR_CODE_VALIDATION_INVALID_DITTO_CONFIG: return "ValidationInvalidDittoConfig";
       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";
@@ -189,7 +192,11 @@ Function dittoffi_try_verify_license(Runtime &runtime) {
     dittoffi_result_void_t res = ::dittoffi_try_verify_license(ditto, license.c_str());
 
     Object obj(runtime);
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }
@@ -269,7 +276,11 @@ Function dittoffi_try_base64_decode(Runtime &runtime)
 
     Object obj(runtime);
     obj.setProperty(runtime, "success", cSlicedBoxToJSSlicedBox(runtime, res.success));
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }

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

@@ -127,7 +127,11 @@ Function dittoffi_presence_try_set_peer_metadata_json(Runtime &runtime)
     dittoffi_result_void_t res = ::dittoffi_presence_try_set_peer_metadata_json(ditto, peer_info);
 
     Object obj(runtime);
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }

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

@@ -48,7 +48,11 @@ Function dittoffi_ditto_try_start_sync(Runtime &runtime)
     dittoffi_result_void_t res = ::dittoffi_ditto_try_start_sync(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
 
     Object obj(runtime);
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
 
     return obj;
   });

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

@@ -161,12 +161,17 @@ Function dittoffi_ditto_try_set_transport_config(Runtime &runtime)
     dittoffi_result_void_t res = ::dittoffi_ditto_try_set_transport_config(ditto, transport_config_cbor, should_validate);
 
     Object obj(runtime);
-    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    if (res.error != nullptr) {
+      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    } else {
+      obj.setProperty(runtime, "error", Value::null());
+    }
     return obj;
   });
 }
 
-Function dittoffi_ditto_transport_config(Runtime &runtime)
+
+Function dittoffi_ditto_set_cloud_sync_enabled(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -177,13 +182,15 @@ Function dittoffi_ditto_transport_config(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    bool enable_ditto_cloud_sync = arguments[1].asBool();
 
-    slice_boxed_uint8_t transport_config_cbor = ::dittoffi_ditto_transport_config(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return cSlicedBoxToJSSlicedBox(runtime, transport_config_cbor);
+    ::dittoffi_ditto_set_cloud_sync_enabled(ditto, enable_ditto_cloud_sync);
+    return {};
   });
 }
 
-Function dittoffi_ditto_set_cloud_sync_enabled(Runtime &runtime)
+Function ditto_register_transport_condition_changed_callback(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -195,30 +202,28 @@ Function dittoffi_ditto_set_cloud_sync_enabled(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    bool enable_ditto_cloud_sync = arguments[1].asBool();
-
-    ::dittoffi_ditto_set_cloud_sync_enabled(ditto, enable_ditto_cloud_sync);
+    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 {};
   });
 }
 
-Function ditto_register_transport_condition_changed_callback(Runtime &runtime)
+Function dittoffi_ditto_transport_config(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
                                                                STRINGIFIED_FUNC_NAME()),
-                                          0,
+                                          1,
                                           [](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 {};
+    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    slice_boxed_uint8_t transport_config_cbor = ::dittoffi_ditto_transport_config(ditto);
+    return cSlicedBoxToJSSlicedBox(runtime, transport_config_cbor);
   });
 }
 }

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

@@ -46,6 +46,13 @@ namespace sharedjsi
     // Lifecycle
     REGISTER_JS_FUNCTION(ditto_init_sdk_version);
     REGISTER_JS_FUNCTION(dittoffi_ditto_try_new_blocking);
+    REGISTER_JS_FUNCTION(dittoffi_ditto_open_throws);
+    REGISTER_JS_FUNCTION(dittoffi_DEFAULT_DATABASE_ID);
+    REGISTER_JS_FUNCTION(dittoffi_DITTO_DEVELOPMENT_PROVIDER);
+    REGISTER_JS_FUNCTION(dittoffi_ditto_config_default);
+    REGISTER_JS_FUNCTION(dittoffi_ditto_config);
+    REGISTER_JS_FUNCTION(dittoffi_ditto_transport_config);
+    REGISTER_JS_FUNCTION(dittoffi_ditto_open_async_throws);
     REGISTER_JS_FUNCTION(ditto_shutdown);
     REGISTER_JS_FUNCTION(ditto_free);
 
@@ -100,6 +107,8 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(dittoffi_query_result_free);
     REGISTER_JS_FUNCTION(dittoffi_query_result_item_free);
     REGISTER_JS_FUNCTION(dittoffi_query_result_item_new);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_has_commit_id);
+    REGISTER_JS_FUNCTION(dittoffi_query_result_commit_id);
 
     // Differ
     REGISTER_JS_FUNCTION(dittoffi_differ_new);
@@ -169,7 +178,6 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_sdk_transports_error_value);
     REGISTER_JS_FUNCTION(ditto_sdk_transports_error_free);
     REGISTER_JS_FUNCTION(dittoffi_ditto_try_set_transport_config);
-    REGISTER_JS_FUNCTION(dittoffi_ditto_transport_config);
     REGISTER_JS_FUNCTION(dittoffi_ditto_set_cloud_sync_enabled);
     REGISTER_JS_FUNCTION(ditto_register_transport_condition_changed_callback);
 
@@ -200,9 +208,11 @@ namespace sharedjsi
     // IO
     REGISTER_JS_FUNCTION(readFile);
     REGISTER_JS_FUNCTION(copyFile);
+    REGISTER_JS_FUNCTION(dittoffi_ditto_absolute_persistence_directory);
 
     // createDirectory() doesn't fit our macro, as it requires an additional parameter
     String defaultDirectory = parameters.getProperty(runtime, "defaultDirectory").asString(runtime);
     runtime.global().setProperty(runtime, "createDirectory", createDirectory(runtime, defaultDirectory));
+    runtime.global().setProperty(runtime, "getDefaultDirectory", getDefaultDirectory(runtime, defaultDirectory));
   }
 }