@dittolive/ditto 4.5.1 → 4.5.2-rc.2

package/package.json

@@ -1,28 +1,16 @@
 {
+  "name": "@dittolive/ditto",
+  "version": "4.5.2-rc.2",
+  "description": "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
+  "homepage": "https://ditto.live",
+  "license": "SEE LICENSE IN LICENSE.md",
+
   "author": {
-    "email": "contact@ditto.live",
     "name": "DittoLive Incorporated.",
+    "email": "contact@ditto.live",
     "url": "https://ditto.live"
   },
-  "browser": "web/ditto.es6.js",
-  "browser/umd": "web/ditto.umd.js",
-  "browserslist": [
-    "defaults"
-  ],
-  "dependencies": {
-    "@ungap/weakrefs": "^0.2.0",
-    "cbor-js": "^0.1.0",
-    "cbor-redux": "^1.0.0",
-    "fastestsmallesttextencoderdecoder": "^1.0.22"
-  },
-  "description": "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
-  "devDependencies": {
-    "serve": "^14.2.0"
-  },
-  "engines": {
-    "node": ">=14"
-  },
-  "homepage": "https://ditto.live",
+
   "keywords": [
     "ditto",
     "dittolive",
@@ -33,14 +21,31 @@
     "sync",
     "p2p"
   ],
-  "license": "SEE LICENSE IN LICENSE.md",
+
+  "engines": {
+    "node": ">=14"
+  },
+
+  "browserslist": [
+    "defaults"
+  ],
+
   "main": "node/ditto.cjs.js",
-  "name": "@dittolive/ditto",
+  "browser": "web/ditto.es6.js",
+  "browser/umd": "web/ditto.umd.js",
+  "types": "types/ditto.d.ts",
   "react-native": "react-native/src/index.ts",
+
   "scripts": {
-    "play:node": "node --experimental-repl-await --unhandled-rejections=strict playground.cjs",
-    "play:web": "npx serve --listen 5285"
+    "play:web": "npx serve --listen 5285",
+    "play:node": "node --experimental-repl-await --unhandled-rejections=strict playground.cjs"
   },
-  "types": "types/ditto.d.ts",
-  "version": "4.5.1"
+
+  "dependencies": {
+    "cbor-redux": "^1.0.0"
+  },
+
+  "devDependencies": {
+    "serve": "^14.2.0"
+  }
 }

package/react-native/android/build.gradle

@@ -153,7 +153,7 @@ dependencies {
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
-  implementation files('libs/ditto.aar')
+  implementation "live.ditto:ditto:4.5.2-rc.2"
 }
 
 if (isNewArchitectureEnabled()) {
@@ -169,7 +169,7 @@ task downloadBinaries {
         def defaultArchitectures = ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']
 
         defaultArchitectures.each { arch ->
-            def fileUrl = "https://software.ditto.live/react-native/ditto/4.5.1/android/${arch}/libdittoffi.a"
+            def fileUrl = "https://software.ditto.live/react-native/ditto/4.5.2-rc.2/android/${arch}/libdittoffi.a"
 
             new File("${project.projectDir}/../dittoffi/android/${arch}").mkdirs()
             def localFilePath = "${project.projectDir}/../dittoffi/android/${arch}/libdittoffi.a"
@@ -184,20 +184,3 @@ task downloadBinaries {
     }
 }
 preBuild.dependsOn downloadBinaries
-
-task downloadAar {
-    def fileUrl = "https://software.ditto.live/react-native/ditto/4.5.1/android/ditto.aar"
-
-    doLast {
-        new File("${project.projectDir}/libs").mkdirs()
-
-        def localFilePath = "${project.projectDir}/libs/ditto.aar"
-        if (!new File(localFilePath).exists()) {
-            println "Downloading file: $fileUrl"
-            ant.get(src: fileUrl, dest: localFilePath, verbose: true)
-        } else {
-            println "File already exists, skipping download: $localFilePath"
-        }
-    }
-}
-preBuild.dependsOn downloadAar

package/react-native/cpp/include/Arc.hpp

@@ -0,0 +1,141 @@
+#ifndef _ARC_
+#define _ARC_
+
+#include <atomic>
+#include <cassert>
+#include <utility>
+
+namespace sharedjsi {
+
+template <typename T> struct ArcPointee {
+  T value;
+  mutable std::atomic<size_t> strong_count;
+
+  ArcPointee(T &&value, size_t strong_count)
+      : value /* = */ (std::move(value)), strong_count /* = */ (strong_count) {}
+};
+
+template <typename T> class Arc {
+public:
+  // Post-condition: refcount = 1.
+  Arc(T value) noexcept
+      : ptr /* = */ (new ArcPointee<T>(std::move(value), 1)) {}
+
+  // Post-condition: refcount ±= 0; schedules dtor glue to `-= 1`.
+  // There has to be a 1-to-1 relation between `into_raw()` and `from_raw()`.
+  static Arc<T> from_raw(void *ptr) noexcept {
+    return Arc(static_cast<ArcPointee<T> *>(ptr));
+  }
+
+  // The equivalent of boost's `detach()`.
+  // Post-condition: refcount ±= 0; disables the `-= 1` eventual dtor glue.
+  // There has to be a 1-to-1 relation between `into_raw()` and `from_raw()`.
+  static void *into_raw(ArcPointee<T> &&self) noexcept {
+    auto ptr = self.ptr;
+    self.ptr = nullptr;
+    return static_cast<void *>(ptr);
+  }
+
+  // The equivalent of boost's `get()`.
+  // Post-condition: refcount ±= 0; dtor untouched.
+  static void *as_raw(Arc<T> const &arc) noexcept { return arc.ptr; }
+
+  // Borrow a `void *` as a `Arc<T>`, *temporarily*.
+  // (i.e., without touching the refcount nor setting up any ownership).
+  //   - You could then use the copy (clone) ctor to get back an owned `Arc<T>`,
+  //     via the retain therein.
+  // Post-condition: refcount ±= 0; dtor not enabled.
+  static Arc<T> &borrow_from_raw(void *&ptr) noexcept {
+    return *reinterpret_cast<Arc<T> *>(&ptr);
+  }
+
+  // Copy (clone) constructor
+  // Post-condition: refcount += 1; schedules new `-= 1` dtor glue.
+  Arc(Arc<T> const &other) noexcept : ptr /* = */ (other.ptr) {
+    ++(ptr->strong_count);
+  }
+
+  // Destructor / dtor.
+  // Post-condition: refcount = -1.
+  ~Arc() {
+    if (ptr != nullptr) { // <- if not moved from.
+      size_t count = --(ptr->strong_count);
+      if (count == 0) {
+        delete ptr;
+      }
+    }
+  }
+
+  // Move constructor
+  // Post-condition: refcount ±= 0 (and `rhs.ptr == nullptr`); moves dtor glue
+  // from `rhs` to `this`.
+  Arc(Arc<T> &&rhs) noexcept : ptr /* = */ (rhs.ptr) { rhs.ptr = nullptr; }
+
+  // Using `swap()`, we can use temporaries to derive the tricky assignments
+  // semantics off the above constructor & destructor operations, thanks to the
+  // C++ RAII semantics of the temporary. Post-condition: refcount ±= 0.
+  void swap(Arc<T> &rhs) noexcept {
+    ArcPointee<T> *rhs_ptr = rhs.ptr;
+    rhs.ptr = this->ptr;
+    this->ptr = rhs_ptr;
+  }
+
+  // Copy (clone) assignment.
+  // Post-condition: rhs refcount += 1; orig `*this` destroyed; schedules new
+  // `-= 1` dtor glue.
+  Arc<T> &operator=(Arc<T> const &rhs) noexcept {
+    {
+      Arc temporary{rhs}; // copy ctor: +1 of rhs
+      temporary.swap(*this);
+    } // dtor: -1 on what used to be `*this`.
+    return *this;
+  }
+
+  // Move assignment
+  // Post-condition: rhs refcount ±= 0; `rhs.ptr == nullptr`; orig `*this`
+  // destroyed. Moved dtor.
+  Arc<T> &operator=(Arc<T> &&rhs) noexcept {
+    {
+      Arc<T> temporary{
+          std::move(rhs)}; // move ctor: +0 of rhs; `rhs` is now `nullptr`.
+      temporary.swap(*this);
+    } // dtor: -1 on what used to be `*this`.
+    return *this;
+  }
+
+  // Deref
+  // Post-condition: rhs refcount ±= 0; dtor untouched.
+  T &operator*() const noexcept {
+    assert(ptr != nullptr);
+    return ptr->value;
+  }
+
+  // Post-condition: rhs refcount ±= 0; dtor untouched.
+  T *operator->() const noexcept {
+    assert(ptr != nullptr);
+    return &ptr->value;
+  }
+
+private:
+  ArcPointee<T> *ptr;
+
+  // from raw
+  Arc<T>(ArcPointee<T> *ptr) : ptr(ptr) {}
+};
+
+#define DEFINE_RETAIN_RELEASE_FOR(T, retain, release)                          \
+  extern "C" {                                                                 \
+  /* Post-condition: refcount += 1; dtor untouched. */                         \
+  static void retain(void *ptr) {                                              \
+    ++(static_cast<ArcPointee<T> *>(ptr)->strong_count);                \
+  }                                                                            \
+                                                                               \
+  /* Post-condition: refcount -= 1; dtor untouched. */                         \
+  static void release(void *ptr) { Arc<T>::from_raw(ptr); }             \
+  }                                                                            \
+  static_assert(true,                                                          \
+                "") // <- to require a semi-colon when the macro is invoked.
+
+} // namespace sharedjsi
+
+#endif // _ARC_

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

@@ -7,7 +7,8 @@ using namespace facebook::jsi;
 
 namespace sharedjsi
 {
-Function uninitialized_ditto_make(Runtime &runtime);
+Function ditto_init_sdk_version(Runtime &runtime);
+Function ditto_uninitialized_ditto_make(Runtime &runtime);
 Function ditto_shutdown(Runtime &runtime);
 Function ditto_free(Runtime &runtime);
 Function ditto_make(Runtime &runtime);

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

@@ -15,8 +15,9 @@ Function dittoffi_error_description(Runtime &runtime);
 Function dittoffi_error_free(Runtime &runtime);
 Function ditto_set_connect_retry_interval(Runtime &runtime);
 Function ditto_get_sdk_version(Runtime &runtime);
+Function dittoffi_get_sdk_semver(Runtime &runtime);
 Function ditto_small_peer_info_set_transport_config_data(Runtime &runtime);
-Function verify_license(Runtime &runtime);
+Function ditto_verify_license(Runtime &runtime);
 Function ditto_run_garbage_collection(Runtime &runtime);
 Function ditto_set_static_websocket_clients(Runtime &runtime);
 Function ditto_set_sync_group(Runtime &runtime);

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

@@ -12,6 +12,8 @@ Function ditto_small_peer_info_get_is_enabled(Runtime &runtime);
 Function ditto_small_peer_info_set_enabled(Runtime &runtime);
 Function ditto_small_peer_info_get_sync_scope(Runtime &runtime);
 Function ditto_small_peer_info_set_sync_scope(Runtime &runtime);
+Function ditto_small_peer_info_get_metadata(Runtime &runtime);
+Function ditto_small_peer_info_set_metadata(Runtime &runtime);
 }
 
 #endif /* SmallPeerInfo_H */

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

@@ -1,18 +1,20 @@
 #include "Utils.h"
-#include "RetainableState.h"
+#include "Arc.hpp"
 
 #include <Authentication.h>
 
 namespace sharedjsi
 {
 
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
 extern "C"
 {
 void v_auth_client_validity_update(void *ctx, int is_web_valid, int is_x509_valid)
 {
-  boost::intrusive_ptr<RetainableState> const wrapped_state {static_cast<RetainableState *>(ctx), true};
-  ditto_enqueue_call([=, wrapped_state=std::move(wrapped_state)](Runtime *runtime) {
-    wrapped_state->jsCallback.call(*runtime,
+  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.
+  ditto_enqueue_call([=, jsCallback=Arc<Function>(borrowedJsCallback)](Runtime *runtime) {
+    jsCallback->call(*runtime,
                                    Value(static_cast<double>(is_web_valid)),
                                    Value(static_cast<double>(is_x509_valid)));
   });
@@ -20,9 +22,10 @@ void v_auth_client_validity_update(void *ctx, int is_web_valid, int is_x509_vali
 
 void v_auth_client_expiring_callback(void *ctx, uint32_t secs_until_expiry)
 {
-  boost::intrusive_ptr<RetainableState> const wrapped_state {static_cast<RetainableState *>(ctx), true};
-  ditto_enqueue_call([=, wrapped_state=std::move(wrapped_state)](Runtime *runtime) {
-    wrapped_state->jsCallback.call(*runtime,
+  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.
+  ditto_enqueue_call([=, jsCallback=Arc<Function>(borrowedJsCallback)](Runtime *runtime) {
+    jsCallback->call(*runtime,
                                    Value(static_cast<double>(secs_until_expiry)));
   });
 }
@@ -34,11 +37,11 @@ Function ditto_auth_client_set_validity_listener(Runtime &runtime)
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
     Function jsCallback = arguments[1].getObject(runtime).getFunction(runtime);
-    auto wrappedStateFfiWrapper = boost::intrusive_ptr<RetainableState>(new RetainableState(std::move(jsCallback)));
+    Arc<Function> wrappedStateFfiWrapper /* = */ (std::move(jsCallback));
 
     ::ditto_auth_client_set_validity_listener(
                                               ditto,
-                                              wrappedStateFfiWrapper.get(),
+                                              Arc<Function>::as_raw(wrappedStateFfiWrapper),
                                               v_retain,
                                               v_release,
                                               v_auth_client_validity_update);
@@ -121,12 +124,12 @@ Function ditto_auth_client_make_login_provider(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     Function expiringCallback = arguments[0].getObject(runtime).getFunction(runtime);
-    auto wrappedStateFfiWrapper = boost::intrusive_ptr<RetainableState>(new RetainableState(std::move(expiringCallback)));
+    Arc<Function> wrappedStateFfiWrapper(std::move(expiringCallback));
 
-    CLoginProvider_t *loginProvider = ::ditto_auth_client_make_login_provider(wrappedStateFfiWrapper.get(),
-                                                                 v_retain,
-                                                                 v_release,
-                                                                 v_auth_client_expiring_callback);
+    CLoginProvider_t *loginProvider = ::ditto_auth_client_make_login_provider(Arc<Function>::as_raw(wrappedStateFfiWrapper),
+                                                                              v_retain,
+                                                                              v_release,
+                                                                              v_auth_client_expiring_callback);
 
     return cPointerToJSPointerObject(runtime, loginProvider);
   });

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

@@ -1,27 +1,29 @@
-#include <boost/smart_ptr/intrusive_ptr.hpp>
-#include <boost/smart_ptr/intrusive_ref_counter.hpp>
 #include <DQL.h>
 #include <dittoffi.h>
 
+#include "Arc.hpp"
 #include "Utils.h"
-#include "RetainableState.h"
 #include "LiveQuery.h"
 
 namespace sharedjsi
 {
 
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
+
 extern "C" {
 void v_change_handler_with_query_result(void *ctx, ChangeHandlerWithQueryResult_t result)
 {
-  boost::intrusive_ptr<RetainableState> const wrapped_state {static_cast<RetainableState *>(ctx), true};
-  ditto_enqueue_call([=, wrapped_state=std::move(wrapped_state)](Runtime *jsi) {
+  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);
+  ditto_enqueue_call([=](Runtime *jsi) {
     Runtime &runtime = *jsi;
     CDqlResponse_t *query_result = result.query_result;
 
     Object obj(runtime);
     obj.setProperty(runtime, "query_result", cPointerToJSPointerObject(runtime, query_result));
 
-    wrapped_state->jsCallback.call(runtime, obj);
+    jsCallback->call(runtime, obj);
   });
 }
 }
@@ -122,7 +124,7 @@ Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime
     slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
 
     Function jsCallback = arguments[3].getObject(runtime).getFunction(runtime);
-    auto wrappedStateFfiWrapper = boost::intrusive_ptr<RetainableState>(new RetainableState(std::move(jsCallback)));
+    Arc<Function> wrappedStateFfiWrapper(std::move(jsCallback));
 
     LiveQueryAvailability lq_availability = LIVE_QUERY_AVAILABILITY_ALWAYS;
     //    std::string lq_availability_str = arguments[3].getString(runtime).utf8(runtime);
@@ -139,7 +141,7 @@ Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime
                                                                                            query,
                                                                                            query_args_cbor,
                                                                                            lq_availability,
-                                                                                           wrappedStateFfiWrapper.get(),
+                                                                                           Arc<Function>::as_raw(wrappedStateFfiWrapper),
                                                                                            v_retain,
                                                                                            v_release,
                                                                                            v_change_handler_with_query_result);

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

@@ -4,7 +4,7 @@
 
 namespace sharedjsi
 {
-Function uninitialized_ditto_make(Runtime &runtime)
+Function ditto_uninitialized_ditto_make(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -16,7 +16,7 @@ Function uninitialized_ditto_make(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     std::string path = jsTypedArrayToCString(runtime, arguments[0]);
-    UninitializedDitto_t *pointer = ::uninitialized_ditto_make(path.c_str());
+    UninitializedDitto_t *pointer = ::ditto_uninitialized_ditto_make(path.c_str());
     return cPointerToJSPointerObject(runtime, pointer);
   });
 }
@@ -72,4 +72,39 @@ Function ditto_make(Runtime &runtime)
     return cPointerToJSPointerObject(runtime, pointer);
   });
 }
+
+
+Function ditto_init_sdk_version(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::string platform_str = arguments[0].toString(runtime).utf8(runtime);
+    std::string language_str = arguments[1].toString(runtime).utf8(runtime);
+    std::string semver_str = arguments[2].toString(runtime).utf8(runtime);
+    const char *semver = semver_str.c_str();
+
+    Language_t language = LANGUAGE_UNKNOWN;
+    if (language_str == "JavaScript") {
+      language = LANGUAGE_JAVA_SCRIPT;
+    }
+
+    Platform_t platform = PLATFORM_UNKNOWN;
+    if (platform_str == "Ios") {
+      platform = PLATFORM_IOS;
+    } else if (platform_str == "Android") {
+      platform = PLATFORM_ANDROID;
+    }
+
+    ::ditto_init_sdk_version(platform, language, semver);
+    return Value();
+  });
+}
+
 }

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

@@ -1,11 +1,10 @@
+
 #include "Utils.h"
-#include "RetainableState.h"
+#include "LiveQuery.h"
 
 namespace sharedjsi
 {
 
-// TODO: Bridge int64_t! When we'll actually reach a number as big as int64, it will crash.
-
 Function ditto_live_query_signal_available_next(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,

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

@@ -145,9 +145,21 @@ Function ditto_get_sdk_version(Runtime &runtime) {
   });
 }
 
+Function dittoffi_get_sdk_semver(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
+                                          {
+    return cPointerToJSPointerObject<char>(runtime, ::dittoffi_get_sdk_semver());
+  });
+}
 
-
-Function verify_license(Runtime &runtime) {
+Function ditto_verify_license(Runtime &runtime) {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
                                                                STRINGIFIED_FUNC_NAME()),
@@ -159,7 +171,7 @@ Function verify_license(Runtime &runtime) {
                                           {
     std::string license = arguments[0].toString(runtime).utf8(runtime);
     char **out_err_msg = NULL;
-    LicenseVerificationResult_t res = ::verify_license(license.c_str(), out_err_msg);
+    LicenseVerificationResult_t res = ::ditto_verify_license(license.c_str(), out_err_msg);
 
     std::string result;
     switch (res) {

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

@@ -1,19 +1,21 @@
 #include "Utils.h"
-#include "RetainableState.h"
+#include "Arc.hpp"
 
 #include <Presence.h>
 
 namespace sharedjsi
 {
 
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
 extern "C"
 {
 void v_presence_callback(void *ctx, char const *str)
 {
-  boost::intrusive_ptr<RetainableState> const wrapped_state {static_cast<RetainableState *>(ctx), true};
-  ditto_enqueue_call([=, wrapped_state=std::move(wrapped_state), cpp_string = std::string(str)](Runtime *jsi) {
+  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.
+  ditto_enqueue_call([=, jsCallback=Arc<Function>(borrowedJsCallback), cpp_string = std::string(str)](Runtime *jsi) {
     Runtime &runtime = *jsi;
-    wrapped_state->jsCallback.call(runtime, cPointerToJSPointerObject<char>(runtime, cpp_string.c_str()));
+    jsCallback->call(runtime, cPointerToJSPointerObject<char>(runtime, cpp_string.c_str()));
   });
 }
 }
@@ -47,10 +49,10 @@ Function ditto_register_presence_v3_callback(Runtime &runtime)
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
     Function presence_callback = arguments[1].getObject(runtime).getFunction(runtime);
-    auto wrappedStateFfiWrapper = boost::intrusive_ptr<RetainableState>(new RetainableState(std::move(presence_callback)));
+    Arc<Function> wrappedStateFfiWrapper /* = */ (std::move(presence_callback));
 
     ::ditto_register_presence_callback_v3(ditto,
-                                          wrappedStateFfiWrapper.get(),
+                                          Arc<Function>::as_raw(wrappedStateFfiWrapper),
                                           v_retain,
                                           v_release,
                                           v_presence_callback);

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

@@ -105,4 +105,38 @@ Function ditto_small_peer_info_set_sync_scope(Runtime &runtime) {
     return Value();
   });
 }
+
+Function ditto_small_peer_info_get_metadata(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
+                                          {
+    char *metadata = ::ditto_small_peer_info_get_metadata(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return String::createFromUtf8(runtime, metadata);
+  });
+
+}
+
+Function ditto_small_peer_info_set_metadata(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]);
+    std::string metadata_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *metadata = metadata_str.c_str();
+
+    return ::ditto_small_peer_info_set_metadata(ditto, metadata);
+  });
+}
 }

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

@@ -3,7 +3,6 @@
 
 #include "main.h"
 #include "Utils.h"
-#include "RetainableState.h"
 #include "DQL.h"
 #include "Document.h"
 #include "Authentication.h"
@@ -37,7 +36,8 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_identity_config_make_online_with_authentication);
 
     // Lifecycle
-    REGISTER_JS_FUNCTION(uninitialized_ditto_make);
+    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);
@@ -109,6 +109,8 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_small_peer_info_set_enabled);
     REGISTER_JS_FUNCTION(ditto_small_peer_info_get_sync_scope);
     REGISTER_JS_FUNCTION(ditto_small_peer_info_set_sync_scope);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_get_metadata);
+    REGISTER_JS_FUNCTION(ditto_small_peer_info_set_metadata);
 
     // FFI functions
     REGISTER_JS_FUNCTION(withOutBoxCBytes);
@@ -136,11 +138,12 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_set_connect_retry_interval);
     REGISTER_JS_FUNCTION(ditto_set_device_name);
     REGISTER_JS_FUNCTION(ditto_get_sdk_version);
+    REGISTER_JS_FUNCTION(dittoffi_get_sdk_semver);
     REGISTER_JS_FUNCTION(ditto_error_message);
     REGISTER_JS_FUNCTION(dittoffi_error_code);
     REGISTER_JS_FUNCTION(dittoffi_error_description);
     REGISTER_JS_FUNCTION(dittoffi_error_free);
-    REGISTER_JS_FUNCTION(verify_license);
+    REGISTER_JS_FUNCTION(ditto_verify_license);
     REGISTER_JS_FUNCTION(ditto_run_garbage_collection);
     REGISTER_JS_FUNCTION(ditto_set_static_websocket_clients);
     REGISTER_JS_FUNCTION(ditto_set_sync_group);