@dittolive/ditto 4.5.4 → 4.6.0

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

@@ -4,23 +4,6 @@
 
 namespace sharedjsi
 {
-Function ditto_uninitialized_ditto_make(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 path = jsTypedArrayToCString(runtime, arguments[0]);
-    UninitializedDitto_t *pointer = ::ditto_uninitialized_ditto_make(path.c_str());
-    return cPointerToJSPointerObject(runtime, pointer);
-  });
-}
-
 Function ditto_shutdown(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
@@ -64,11 +47,11 @@ Function ditto_make(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
-    UninitializedDitto_t *uninit_ditto = jsPointerObjectToCPointer<UninitializedDitto_t>(runtime, arguments[0]);
+    std::string path = jsTypedArrayToCString(runtime, arguments[0]);
     CIdentityConfig_t *identity_config = jsPointerObjectToCPointer<CIdentityConfig_t>(runtime, arguments[1]);
     HistoryTracking_t history_tracking = HISTORY_TRACKING_DISABLED;
 
-    CDitto_t *pointer = ::ditto_make(uninit_ditto, identity_config, history_tracking);
+    CDitto_t *pointer = ::ditto_make(path.c_str(), identity_config, history_tracking);
     return cPointerToJSPointerObject(runtime, pointer);
   });
 }

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

@@ -5,8 +5,6 @@
 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,
@@ -19,7 +17,7 @@ Function ditto_live_query_signal_available_next(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    int64_t liveQueryId = arguments[1].asNumber();
+    int64_t liveQueryId = arguments[1].asBigInt(runtime).asInt64(runtime);
 
     ::ditto_live_query_signal_available_next(ditto, liveQueryId);
     return Value();
@@ -38,7 +36,7 @@ Function ditto_live_query_start(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    int64_t liveQueryId = arguments[1].asNumber();
+    int64_t liveQueryId = arguments[1].asBigInt(runtime).asInt64(runtime);
     int32_t res = ::ditto_live_query_start(ditto, liveQueryId);
     return static_cast<double>(res);
   });
@@ -56,7 +54,7 @@ Function ditto_live_query_stop(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    int64_t liveQueryId = arguments[1].asNumber();
+    int64_t liveQueryId = arguments[1].asBigInt(runtime).asInt64(runtime);
 
     ::ditto_live_query_stop(ditto, liveQueryId);
     return Value();

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

@@ -1,4 +1,3 @@
-
 #include "Logger.h"
 #include "Utils.h"
 
@@ -7,194 +6,194 @@
 namespace sharedjsi
 {
 
-  CLogLevel_t jsLogLevelStringToCLogLevel(std::string log_level)
-  {
-    static const std::unordered_map<std::string, CLogLevel_t> lookup = {
-        {"Error", C_LOG_LEVEL_ERROR},
-        {"Warning", C_LOG_LEVEL_WARNING},
-        {"Info", C_LOG_LEVEL_INFO},
-        {"Debug", C_LOG_LEVEL_DEBUG},
-        {"Verbose", C_LOG_LEVEL_VERBOSE},
-    };
-
-    auto it = lookup.find(log_level.c_str());
-    if (it != lookup.end())
-    {
-      return it->second;
-    }
-    else
-    {
-      throw std::invalid_argument("Invalid log level");
-    }
-  };
-
-  std::string cLogLevelToJSLogLevelString(CLogLevel_t log_level)
-  {
-    static const std::unordered_map<CLogLevel_t, std::string> lookup = {
-        {C_LOG_LEVEL_ERROR, "Error"},
-        {C_LOG_LEVEL_WARNING, "Warning"},
-        {C_LOG_LEVEL_INFO, "Info"},
-        {C_LOG_LEVEL_DEBUG, "Debug"},
-        {C_LOG_LEVEL_VERBOSE, "Verbose"},
-    };
-
-    auto it = lookup.find(log_level);
-    if (it != lookup.end())
-    {
-      return it->second;
-    }
-    else
-    {
-      throw std::invalid_argument("Invalid log level");
-    }
+CLogLevel_t jsLogLevelStringToCLogLevel(std::string log_level)
+{
+  static const std::unordered_map<std::string, CLogLevel_t> lookup = {
+    {"Error", C_LOG_LEVEL_ERROR},
+    {"Warning", C_LOG_LEVEL_WARNING},
+    {"Info", C_LOG_LEVEL_INFO},
+    {"Debug", C_LOG_LEVEL_DEBUG},
+    {"Verbose", C_LOG_LEVEL_VERBOSE},
   };
 
-  Function ditto_log(Runtime &runtime)
+  auto it = lookup.find(log_level.c_str());
+  if (it != lookup.end())
   {
-    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 log_level_str = arguments[0].toString(runtime).utf8(runtime);
-                                              CLogLevel_t log_level = jsLogLevelStringToCLogLevel(log_level_str);
-
-                                              std::string message_str = jsTypedArrayToCString(runtime, arguments[1]);
-                                              const char *message = message_str.c_str();
-
-                                              ::ditto_log(log_level, message);
-                                              return Value();
-                                            });
+    return it->second;
   }
-
-  Function ditto_logger_minimum_log_level_get(Runtime &runtime)
+  else
   {
-    return Function::createFromHostFunction(runtime,
-                                            PropNameID::forAscii(runtime,
-                                                                 STRINGIFIED_FUNC_NAME()),
-                                            0,
-                                            [](Runtime &runtime,
-                                               const Value &thisValue,
-                                               const Value *arguments,
-                                               size_t count) -> Value
-                                            {
-                                              CLogLevel_t res = ::ditto_logger_minimum_log_level_get();
-                                              std::string log_level = cLogLevelToJSLogLevelString(res);
-                                              return String::createFromUtf8(runtime, log_level);
-                                            });
+    throw std::invalid_argument("Invalid log level");
   }
+};
 
-  Function ditto_logger_minimum_log_level(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 log_level_str = arguments[0].toString(runtime).utf8(runtime);
-                                              CLogLevel_t log_level = jsLogLevelStringToCLogLevel(log_level_str);
-
-                                              ::ditto_logger_minimum_log_level(log_level);
-                                              return Value();
-                                            });
-  }
+std::string cLogLevelToJSLogLevelString(CLogLevel_t log_level)
+{
+  static const std::unordered_map<CLogLevel_t, std::string> lookup = {
+    {C_LOG_LEVEL_ERROR, "Error"},
+    {C_LOG_LEVEL_WARNING, "Warning"},
+    {C_LOG_LEVEL_INFO, "Info"},
+    {C_LOG_LEVEL_DEBUG, "Debug"},
+    {C_LOG_LEVEL_VERBOSE, "Verbose"},
+  };
 
-  Function ditto_logger_set_log_file(Runtime &runtime)
+  auto it = lookup.find(log_level);
+  if (it != lookup.end())
   {
-    return Function::createFromHostFunction(runtime,
-                                            PropNameID::forAscii(runtime,
-                                                                 STRINGIFIED_FUNC_NAME()),
-                                            0,
-                                            [](Runtime &runtime,
-                                               const Value &thisValue,
-                                               const Value *arguments,
-                                               size_t count) -> Value
-                                            {
-                                              ::ditto_logger_set_log_file(arguments[0].toString(runtime).utf8(runtime).c_str());
-                                              return Value();
-                                            });
+    return it->second;
   }
-
-  Function ditto_logger_emoji_headings_enabled(Runtime &runtime)
+  else
   {
-    return Function::createFromHostFunction(runtime,
-                                            PropNameID::forAscii(runtime,
-                                                                 STRINGIFIED_FUNC_NAME()),
-                                            0,
-                                            [](Runtime &runtime,
-                                               const Value &thisValue,
-                                               const Value *arguments,
-                                               size_t count) -> Value
-                                            {
-                                              ::ditto_logger_emoji_headings_enabled(arguments[0].asBool());
-                                              return Value();
-                                            });
+    throw std::invalid_argument("Invalid log level");
   }
+};
 
-  Function ditto_logger_emoji_headings_enabled_get(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_logger_emoji_headings_enabled_get();
-                                            });
-  }
+Function ditto_log(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 log_level_str = arguments[0].toString(runtime).utf8(runtime);
+    CLogLevel_t log_level = jsLogLevelStringToCLogLevel(log_level_str);
+
+    std::string message_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *message = message_str.c_str();
+
+    ::ditto_log(log_level, message);
+    return Value();
+  });
+}
 
-  Function ditto_logger_enabled_get(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_logger_enabled_get();
-                                            });
-  }
+Function ditto_logger_minimum_log_level_get(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
+                                          {
+    CLogLevel_t res = ::ditto_logger_minimum_log_level_get();
+    std::string log_level = cLogLevelToJSLogLevelString(res);
+    return String::createFromUtf8(runtime, log_level);
+  });
+}
 
-  Function ditto_logger_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
-                                            {
-                                              ::ditto_logger_enabled(arguments[0].asBool());
-                                              return Value();
-                                            });
-  }
+Function ditto_logger_minimum_log_level(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 log_level_str = arguments[0].toString(runtime).utf8(runtime);
+    CLogLevel_t log_level = jsLogLevelStringToCLogLevel(log_level_str);
+
+    ::ditto_logger_minimum_log_level(log_level);
+    return Value();
+  });
+}
 
-  std::function<void(CLogLevel_t, const char *)> global_js_callback;
+Function ditto_logger_set_log_file(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_logger_set_log_file(arguments[0].toString(runtime).utf8(runtime).c_str());
+    return Value();
+  });
+}
 
-  extern "C"
+Function ditto_logger_emoji_headings_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
+                                          {
+    ::ditto_logger_emoji_headings_enabled(arguments[0].asBool());
+    return Value();
+  });
+}
+
+Function ditto_logger_emoji_headings_enabled_get(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_logger_emoji_headings_enabled_get();
+  });
+}
+
+Function ditto_logger_enabled_get(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_logger_enabled_get();
+  });
+}
+
+Function ditto_logger_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
+                                          {
+    ::ditto_logger_enabled(arguments[0].asBool());
+    return Value();
+  });
+}
+
+std::function<void(CLogLevel_t, const char *)> global_js_callback;
+
+extern "C"
+{
+void custom_log_callback(CLogLevel_t log_level, const char *message)
+{
+  if (global_js_callback)
   {
-    void custom_log_callback(CLogLevel_t log_level, const char *message)
-    {
-      if (global_js_callback)
-      {
-        global_js_callback(log_level, message);
-      }
-    }
+    global_js_callback(log_level, message);
   }
 }
+}
+}

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

@@ -47,7 +47,7 @@ Function ditto_error_message(Runtime &runtime) {
                                              size_t count) -> Value
                                           {
     char *str = ::ditto_error_message();
-    return String::createFromUtf8(runtime, str ? str : "");
+    return cPointerToJSPointerObject<char>(runtime, str);
   });
 }
 
@@ -95,7 +95,7 @@ Function dittoffi_error_description(Runtime &runtime) {
                                              size_t count) -> Value
                                           {
     char *res = ::dittoffi_error_description(jsPointerObjectToCPointer<dittoffi_error_t>(runtime, arguments[0]));
-    return String::createFromUtf8(runtime, res);
+    return cPointerToJSPointerObject<char>(runtime, res);
   });
 }
 
@@ -264,7 +264,7 @@ Function ditto_set_sync_group(Runtime &runtime) {
   });
 }
 
-Function refCStringToString(Runtime &runtime)
+Function ditto_disable_sync_with_v3(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -275,9 +275,57 @@ Function refCStringToString(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
-    return String::createFromUtf8(runtime, jsPointerObjectToCPointer<char>(runtime, arguments[0]));
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    return ::ditto_disable_sync_with_v3(ditto);
   });
 }
 
 
+Function dittoffi_base64_encode(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> bytes_vec = jsTypedArrayToCVector(runtime, arguments[0]);
+    slice_ref_uint8_t bytes = borrowVecAsRefSlice(bytes_vec);
+
+    std::string padding_mode_str = arguments[1].toString(runtime).utf8(runtime);
+    Base64PaddingMode_t padding_mode = padding_mode_str == "Padded" ? BASE64_PADDING_MODE_PADDED : BASE64_PADDING_MODE_UNPADDED;
+
+    char *res = ::dittoffi_base64_encode(bytes, padding_mode);
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+
+Function dittoffi_try_base64_decode(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 base64_str = jsTypedArrayToCString(runtime, arguments[0]);
+    const char *base64 = base64_str.c_str();
+
+    std::string padding_mode_str = arguments[1].toString(runtime).utf8(runtime);
+    Base64PaddingMode_t padding_mode = padding_mode_str == "Padded" ? BASE64_PADDING_MODE_PADDED : BASE64_PADDING_MODE_UNPADDED;
+
+    dittoffi_result_slice_boxed_uint8_t res = ::dittoffi_try_base64_decode(base64, padding_mode);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cSlicedBoxToJSSlicedBox(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
 }

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

@@ -32,7 +32,7 @@ Function ditto_presence_v3(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     char *res = ::ditto_presence_v3(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return String::createFromUtf8(runtime, res);
+    return cPointerToJSPointerObject<char>(runtime, res);
   });
 }
 

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

@@ -117,7 +117,7 @@ Function ditto_small_peer_info_get_metadata(Runtime &runtime) {
                                              size_t count) -> Value
                                           {
     char *metadata = ::ditto_small_peer_info_get_metadata(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return String::createFromUtf8(runtime, metadata);
+    return cPointerToJSPointerObject<char>(runtime, metadata);
   });
 
 }

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

@@ -52,17 +52,22 @@ Function ditto_sdk_transports_error_value(Runtime &runtime)
     DittoSdkTransportsError_t *outError = jsPointerObjectToCPointer<DittoSdkTransportsError_t>(runtime, arguments[0]);
     DittoSdkTransportsError_t error = ::ditto_sdk_transports_error_value(outError);
 
-    switch (error)
-    {
+    std::string error_string;
+    switch (error) {
       case DITTO_SDK_TRANSPORTS_ERROR_NONE:
-        return String::createFromUtf8(runtime, "None");
+        error_string = "None";
+        break;
       case DITTO_SDK_TRANSPORTS_ERROR_GENERIC:
-        return String::createFromUtf8(runtime, "Generic");
+        error_string = "Generic";
+        break;
       case DITTO_SDK_TRANSPORTS_ERROR_UNAVAILABLE:
-        return String::createFromUtf8(runtime, "Unavailable");
+        error_string = "Unavailable";
+        break;
       default:
         throw "Unimplemented error value";
     }
+    return String::createFromUtf8(runtime, error_string);
+
   });
 }