@dittolive/ditto 4.4.4 → 4.5.0

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

@@ -0,0 +1,271 @@
+#include "Utils.h"
+
+#include <Misc.h>
+#include <unordered_map>
+
+namespace sharedjsi
+{
+Function ditto_tick(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
+                                           {
+                                             ditto_tick(&runtime);
+                                             return Value();
+                                           });
+}
+
+Function ditto_set_device_name(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 device_name_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *device_name = device_name_str.c_str();
+
+    ::ditto_set_device_name(ditto, device_name);
+    return Value();
+  });
+}
+
+Function ditto_error_message(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 *str = ::ditto_error_message();
+    return String::createFromUtf8(runtime, str ? str : "");
+  });
+}
+
+Function dittoffi_error_code(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_error_t *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"},
+    };
+
+    auto it = lookup.find(error_code);
+    if (it != lookup.end()) {
+      return String::createFromUtf8(runtime, it->second);
+    } else {
+      throw std::invalid_argument("Invalid error code");
+    }
+  });
+}
+
+Function dittoffi_error_description(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 *res = ::dittoffi_error_description(jsPointerObjectToCPointer<dittoffi_error_t>(runtime, arguments[0]));
+    return String::createFromUtf8(runtime, res);
+  });
+}
+
+Function dittoffi_error_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_error_free(jsPointerObjectToCPointer<dittoffi_error_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function ditto_set_connect_retry_interval(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]);
+    uint32_t sync_group = static_cast<uint32_t>(arguments[1].asNumber());
+    ::ditto_set_connect_retry_interval(ditto, sync_group);
+    return Value();
+  });
+}
+
+Function ditto_get_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
+                                          {
+    return cPointerToJSPointerObject<char>(runtime, ::ditto_get_sdk_version());
+  });
+}
+
+
+
+Function verify_license(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 license = arguments[0].toString(runtime).utf8(runtime);
+    char **out_err_msg = NULL;
+    LicenseVerificationResult_t res = ::verify_license(license.c_str(), out_err_msg);
+
+    std::string result;
+    switch (res) {
+      case LICENSE_VERIFICATION_RESULT_LICENSE_OK:
+        result = "LicenseOk";
+        break;
+      case LICENSE_VERIFICATION_RESULT_VERIFICATION_FAILED:
+        result = "VerificationFailed";
+        break;
+      case LICENSE_VERIFICATION_RESULT_LICENSE_EXPIRED:
+        result = "LicenseExpired";
+        break;
+      case LICENSE_VERIFICATION_RESULT_UNSUPPORTED_FUTURE_VERSION:
+        result = "UnsupportedFutureVersion";
+        break;
+    }
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "result", String::createFromUtf8(runtime, result));
+    obj.setProperty(runtime, "errorMessage", String::createFromUtf8(runtime, *out_err_msg));
+    return obj;
+  });
+}
+
+Function ditto_run_garbage_collection(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
+                                          {
+    ::ditto_run_garbage_collection(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function ditto_set_static_websocket_clients(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]);
+    Array array = arguments[1].asObject(runtime).asArray(runtime);
+
+    std::vector<std::string> string_storage;
+    string_storage.reserve(array.length(runtime));
+
+    std::vector<const char *> cstring_pointers;
+    cstring_pointers.reserve(array.length(runtime));
+
+    for (size_t i = 0; i < array.length(runtime); ++i) {
+      Value element = array.getValueAtIndex(runtime, i);
+      string_storage.emplace_back(jsTypedArrayToCString(runtime, element));
+      cstring_pointers.push_back(string_storage.back().c_str());
+    }
+
+    slice_ref_char_const_ptr_t slice = { .ptr = cstring_pointers.data(), .len = cstring_pointers.size() };
+
+    uint32_t routing_hint = static_cast<uint32_t>(arguments[2].asNumber());
+
+    ::ditto_set_static_websocket_clients(ditto, slice, routing_hint);
+
+    return Value();
+  });
+}
+
+Function ditto_set_sync_group(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]);
+    uint32_t sync_group = static_cast<uint32_t>(arguments[1].asNumber());
+    ::ditto_set_sync_group(ditto, sync_group);
+    return Value();
+  });
+}
+
+Function refCStringToString(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 String::createFromUtf8(runtime, jsPointerObjectToCPointer<char>(runtime, arguments[0]));
+  });
+}
+
+
+}

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

@@ -0,0 +1,77 @@
+#include "Utils.h"
+#include "RetainableState.h"
+
+#include <Presence.h>
+
+namespace sharedjsi
+{
+
+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) {
+    Runtime &runtime = *jsi;
+    wrapped_state->jsCallback.call(runtime, cPointerToJSPointerObject<char>(runtime, cpp_string.c_str()));
+  });
+}
+}
+
+Function ditto_presence_v3(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 *res = ::ditto_presence_v3(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return String::createFromUtf8(runtime, res);
+  });
+}
+
+Function ditto_register_presence_v3_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 presence_callback = arguments[1].getObject(runtime).getFunction(runtime);
+    auto wrappedStateFfiWrapper = boost::intrusive_ptr<RetainableState>(new RetainableState(std::move(presence_callback)));
+
+    ::ditto_register_presence_callback_v3(ditto,
+                                          wrappedStateFfiWrapper.get(),
+                                          v_retain,
+                                          v_release,
+                                          v_presence_callback);
+    return Value();
+  });
+}
+
+Function ditto_clear_presence_v3_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
+                                          {
+    ::ditto_clear_presence_v3_callback(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+}

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

@@ -0,0 +1,15 @@
+#include "RetainableState.h"
+
+RetainableState::RetainableState(Function jsCallback)
+: jsCallback(std::move(jsCallback)) { }
+
+extern "C" {
+void v_retain(void *ctx) {
+  auto clone = boost::intrusive_ptr<RetainableState>(static_cast<RetainableState *>(ctx), true);
+  clone.detach();
+}
+
+void v_release(void *ctx) {
+  auto _owned = boost::intrusive_ptr<RetainableState>(static_cast<RetainableState *>(ctx), false);
+}
+}

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

@@ -0,0 +1,108 @@
+#include "Utils.h"
+
+#include <Misc.h>
+
+namespace sharedjsi
+{
+
+Function ditto_small_peer_info_set_transport_config_data(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::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t query_args_cbor = borrowVecAsRefSlice(query_args_cbor_vec);
+
+    ::ditto_small_peer_info_set_transport_config_data(ditto, query_args_cbor);
+    return Value();
+  });
+}
+
+Function ditto_small_peer_info_get_is_enabled(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 ::ditto_small_peer_info_get_is_enabled(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_small_peer_info_set_enabled(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]);
+    bool is_enabled = arguments[1].asBool();
+    ::ditto_small_peer_info_set_enabled(ditto, is_enabled);
+    return Value();
+  });
+}
+
+Function ditto_small_peer_info_get_sync_scope(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
+                                          {
+    DittoSmallPeerInfoSyncScope_t sync_scope = ::ditto_small_peer_info_get_sync_scope(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    switch (sync_scope) {
+      case DITTO_SMALL_PEER_INFO_SYNC_SCOPE_LOCAL_PEER_ONLY:
+        return String::createFromUtf8(runtime, "LocalPeerOnly");
+        break;
+      case DITTO_SMALL_PEER_INFO_SYNC_SCOPE_BIG_PEER_ONLY:
+        return String::createFromUtf8(runtime, "BigPeerOnly");
+        break;
+    }
+  });
+}
+
+Function ditto_small_peer_info_set_sync_scope(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 sync_scope_str = arguments[1].toString(runtime).utf8(runtime);
+
+    DittoSmallPeerInfoSyncScope_t sync_scope;
+    if (sync_scope_str == "LocalPeerOnly") {
+      sync_scope = DITTO_SMALL_PEER_INFO_SYNC_SCOPE_LOCAL_PEER_ONLY;
+    } else if (sync_scope_str == "BigPeerOnly") {
+      sync_scope = DITTO_SMALL_PEER_INFO_SYNC_SCOPE_BIG_PEER_ONLY;
+    } else {
+      throw "The string provided for Sync Scope is incorrect. Please ensure it matches the expected format.";
+    }
+
+    ::ditto_small_peer_info_set_sync_scope(ditto, sync_scope);
+    return Value();
+  });
+}
+}