@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

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

@@ -0,0 +1,146 @@
+#include "Utils.h"
+
+#include <Document.h>
+#include <dittoffi.h>
+#include <unordered_map>
+
+namespace sharedjsi
+{
+
+Function ditto_document_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
+                                          {
+    CDocument_t *document = jsPointerObjectToCPointer<CDocument_t>(runtime, arguments[0]);
+    ::ditto_document_free(document);
+    return Value();
+  });
+}
+
+Function ditto_document_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
+                                          {
+    CDocument_t const *document = jsPointerObjectToCPointer<CDocument>(runtime, arguments[0]);
+    slice_boxed_uint8_t res = ::ditto_document_id(document);
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function ditto_document_id_query_compatible(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> id_vec = jsTypedArrayToCVector(runtime, arguments[0]);
+    slice_ref_uint8_t id = borrowVecAsRefSlice(id_vec);
+    
+    std::string stringPrimitiveStr = arguments[1].getString(runtime).utf8(runtime);
+    StringPrimitiveFormat_t stringPrimitiveFormat;
+    if (stringPrimitiveStr == "WithQuotes") {
+      stringPrimitiveFormat = STRING_PRIMITIVE_FORMAT_WITH_QUOTES;
+    } if (stringPrimitiveStr == "WithoutQuotes") {
+      stringPrimitiveFormat = STRING_PRIMITIVE_FORMAT_WITHOUT_QUOTES;
+    } else {
+      throw std::invalid_argument("Invalid string primitive format.");
+    }
+    
+    char *res = ::ditto_document_id_query_compatible(id, stringPrimitiveFormat);
+    return String::createFromUtf8(runtime, res);
+  });
+}
+
+Function ditto_document_get_cbor_with_path_type(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
+                                          {
+    CDocument_t const *document = jsPointerObjectToCPointer<CDocument>(runtime, arguments[0]);
+    std::string path_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *path = path_str.c_str();
+    std::string pathTypeStr = arguments[2].asString(runtime).utf8(runtime);
+    
+    static const std::unordered_map<std::string, PathAccessorType_t> lookup = {
+      {"String", PATH_ACCESSOR_TYPE_STRING},
+      {"Number", PATH_ACCESSOR_TYPE_NUMBER},
+      {"Int", PATH_ACCESSOR_TYPE_INT},
+      {"UInt", PATH_ACCESSOR_TYPE_U_INT},
+      {"Float", PATH_ACCESSOR_TYPE_FLOAT},
+      {"Double", PATH_ACCESSOR_TYPE_DOUBLE},
+      {"Bool", PATH_ACCESSOR_TYPE_BOOL},
+      {"Null", PATH_ACCESSOR_TYPE_NULL},
+      {"Object", PATH_ACCESSOR_TYPE_OBJECT},
+      {"Array", PATH_ACCESSOR_TYPE_ARRAY},
+      {"Any", PATH_ACCESSOR_TYPE_ANY},
+      {"Counter", PATH_ACCESSOR_TYPE_COUNTER},
+      {"Register", PATH_ACCESSOR_TYPE_REGISTER},
+      {"Attachment", PATH_ACCESSOR_TYPE_ATTACHMENT},
+      {"Rga", PATH_ACCESSOR_TYPE_R_W_MAP},
+      {"RWMap", PATH_ACCESSOR_TYPE_R_W_MAP},
+    };
+    
+    PathAccessorType_t path_type;
+    auto it = lookup.find(pathTypeStr);
+    if (it != lookup.end()) {
+      path_type = it->second;
+    } else {
+      throw std::invalid_argument("Invalid path type string");
+    }
+    
+    CBORPathResult_t res = ::ditto_document_get_cbor_with_path_type(document, path, path_type);
+    
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status_code));
+    obj.setProperty(runtime, "cbor", cSlicedBoxToJSSlicedBox(runtime, res.cbor));
+    return obj;
+  });
+}
+
+
+Function ditto_validate_document_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
+                                          {
+    
+    std::vector<uint8_t> doc_id_vec = jsTypedArrayToCVector(runtime, arguments[0]);
+    slice_ref_uint8_t doc_id = borrowVecAsRefSlice(doc_id_vec);
+    
+    slice_boxed_uint8 *out_cbor = jsPointerObjectToCPointer<slice_boxed_uint8>(runtime, arguments[1]);
+    uint32_t res = ::ditto_validate_document_id(doc_id, out_cbor);
+    return static_cast<double>(res);
+  });
+}
+}

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

@@ -0,0 +1,123 @@
+#include "Utils.h"
+
+#include <Identity.h>
+
+namespace sharedjsi
+{
+
+Object convertConfigResultToJSIObject(Runtime &runtime, IdentityConfigResult_t result) {
+  Object obj(runtime);
+  obj.setProperty(runtime, "status_code", (double)result.status_code);
+  obj.setProperty(runtime, "identity_config", cPointerToJSPointerObject(runtime, result.identity_config));
+  return obj;
+}
+
+Function ditto_identity_config_make_online_playground(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 app_id_str = jsTypedArrayToCString(runtime, arguments[0]);
+    std::string shared_token_str = jsTypedArrayToCString(runtime, arguments[1]);
+    std::string base_url_str = jsTypedArrayToCString(runtime, arguments[2]);
+
+    const char *app_id = app_id_str.c_str();
+    const char *shared_token = shared_token_str.c_str();
+    const char *base_url = base_url_str.c_str();
+
+    IdentityConfigResult_t config_result = ::ditto_identity_config_make_online_playground(app_id, shared_token, base_url);
+    return convertConfigResultToJSIObject(runtime, config_result);
+  });
+}
+
+Function ditto_identity_config_make_offline_playground(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 app_id_str = jsTypedArrayToCString(runtime, arguments[0]);
+    const char *app_id = app_id_str.c_str();
+    uint64_t site_id = arguments[1].asNumber();
+
+    IdentityConfigResult_t config_result = ::ditto_identity_config_make_offline_playground(app_id, site_id);
+    return convertConfigResultToJSIObject(runtime, config_result);
+  });
+}
+
+Function ditto_identity_config_make_manual_v0(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 config_cbor_b64_str = jsTypedArrayToCString(runtime, arguments[0]);
+    const char *config_cbor_b64 = config_cbor_b64_str.c_str();
+
+    IdentityConfigResult_t config_result = ::ditto_identity_config_make_manual_v0(config_cbor_b64);
+    return convertConfigResultToJSIObject(runtime, config_result);
+  });
+}
+
+Function ditto_identity_config_make_shared_key(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 app_id_str = jsTypedArrayToCString(runtime, arguments[0]);
+    const char *app_id = app_id_str.c_str();
+
+    std::string shared_key_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *shared_key = shared_key_str.c_str();
+
+    uint64_t site_id = arguments[2].asNumber();
+
+    IdentityConfigResult_t config_result = ::ditto_identity_config_make_shared_key(app_id, shared_key, site_id);
+    return convertConfigResultToJSIObject(runtime, config_result);
+  });
+}
+
+Function ditto_identity_config_make_online_with_authentication(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 app_id_str = jsTypedArrayToCString(runtime, arguments[0]);
+    std::string baseURLVector = jsTypedArrayToCString(runtime, arguments[1]);
+
+    const char *app_id = app_id_str.c_str();
+    const char *base_url = baseURLVector.c_str();
+
+    IdentityConfigResult_t config_result = ::ditto_identity_config_make_online_with_authentication(app_id, base_url);
+    return convertConfigResultToJSIObject(runtime, config_result);
+  });
+}
+}

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

@@ -0,0 +1,110 @@
+#include "Utils.h"
+
+#include <Lifecycle.h>
+
+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,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    ::ditto_shutdown(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function ditto_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
+                                          {
+    ::ditto_free(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+
+Function 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
+                                          {
+    UninitializedDitto_t *uninit_ditto = jsPointerObjectToCPointer<UninitializedDitto_t>(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);
+    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

@@ -0,0 +1,63 @@
+
+#include "Utils.h"
+#include "LiveQuery.h"
+
+namespace sharedjsi
+{
+
+Function ditto_live_query_signal_available_next(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]);
+    int64_t liveQueryId = arguments[1].asNumber();
+
+    ::ditto_live_query_signal_available_next(ditto, liveQueryId);
+    return Value();
+  });
+}
+
+Function ditto_live_query_start(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]);
+    int64_t liveQueryId = arguments[1].asNumber();
+    int32_t res = ::ditto_live_query_start(ditto, liveQueryId);
+    return static_cast<double>(res);
+  });
+}
+
+Function ditto_live_query_stop(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]);
+    int64_t liveQueryId = arguments[1].asNumber();
+
+    ::ditto_live_query_stop(ditto, liveQueryId);
+    return Value();
+  });
+}
+}

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

@@ -0,0 +1,200 @@
+
+#include "Logger.h"
+#include "Utils.h"
+
+#include <unordered_map>
+
+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");
+    }
+  };
+
+  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_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_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();
+                                            });
+  }
+
+  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();
+                                            });
+  }
+
+  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)
+      {
+        global_js_callback(log_level, message);
+      }
+    }
+  }
+}