@dittolive/ditto 4.7.4-rc.2 → 4.7.4

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

@@ -0,0 +1,227 @@
+#include "Utils.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)
+{
+  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)));
+  });
+}
+
+void v_auth_client_expiring_callback(void *ctx, uint32_t secs_until_expiry)
+{
+  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)));
+  });
+}
+}
+
+Function ditto_auth_client_set_validity_listener(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime, PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()), 0, [](Runtime &runtime, Value const &thisValue, Value const *arguments, size_t count) -> Value
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    Function jsCallback = arguments[1].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper /* = */ (std::move(jsCallback));
+
+    ::ditto_auth_client_set_validity_listener(
+                                              ditto,
+                                              Arc<Function>::as_raw(wrappedStateFfiWrapper),
+                                              v_retain,
+                                              v_release,
+                                              v_auth_client_validity_update);
+
+    return Value();
+  });
+}
+
+Function ditto_auth_client_is_web_valid(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_auth_client_is_web_valid(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_auth_client_is_x509_valid(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_auth_client_is_x509_valid(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_auth_client_get_app_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
+                                          {
+    char *appId = ::ditto_auth_client_get_app_id(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return cPointerToJSPointerObject<char>(runtime, appId);
+  });
+}
+
+Function ditto_auth_client_get_site_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
+                                          {
+    uint64_t siteId = ::ditto_auth_client_get_site_id(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return uint64ToBigIntOrNumber(runtime, siteId);
+  });
+}
+
+Function ditto_auth_client_make_login_provider(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    Function expiringCallback = arguments[0].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(expiringCallback));
+
+    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);
+  });
+}
+
+Function ditto_auth_set_login_provider(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    CLoginProvider_t *loginProvider = jsPointerObjectToCPointer<CLoginProvider_t>(runtime, arguments[1]);
+
+    ::ditto_auth_set_login_provider(ditto, loginProvider);
+    return Value();
+  });
+}
+
+Function ditto_auth_client_login_with_token(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 token = jsTypedArrayToCString(runtime, arguments[1]);
+    std::string provider = jsTypedArrayToCString(runtime, arguments[2]);
+
+    return ::ditto_auth_client_login_with_token(ditto, token.c_str(), provider.c_str());
+  });
+}
+
+Function ditto_auth_client_login_with_credentials(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 username = jsTypedArrayToCString(runtime, arguments[1]);
+    std::string password  = jsTypedArrayToCString(runtime, arguments[2]);
+    std::string provider  = jsTypedArrayToCString(runtime, arguments[3]);
+
+    return ::ditto_auth_client_login_with_credentials(ditto, username.c_str(), password.c_str(), provider.c_str());
+  });
+}
+
+Function ditto_auth_client_logout(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_auth_client_logout(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+  });
+}
+
+Function ditto_auth_client_user_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
+                                          {
+    char *res = ::ditto_auth_client_user_id(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+}

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

@@ -0,0 +1,56 @@
+#include "Utils.h"
+
+#include <Collection.h>
+
+namespace sharedjsi
+{
+
+Function ditto_collection_insert_value(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 collection_name_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *collectionName = collection_name_str.c_str();
+    
+    TypedArrayBase typedArrayBase(runtime, arguments[2].asObject(runtime));
+    std::vector<uint8_t> docCborVector = typedArrayBase.toVector(runtime);
+    slice_ref_uint8_t docCbor = { .ptr = docCborVector.data(), .len = docCborVector.size() };
+    
+    WriteStrategyRs_t writeStrategy;
+    std::string writeStrategyStr = arguments[3].asString(runtime).utf8(runtime);
+    
+    if (writeStrategyStr == "Merge") {
+      writeStrategy = WRITE_STRATEGY_RS_MERGE;
+    } else if (writeStrategyStr == "InsertIfAbsent") {
+      writeStrategy = WRITE_STRATEGY_RS_INSERT_IF_ABSENT;
+    } else if (writeStrategyStr == "InsertDefaultIfAbsent") {
+      writeStrategy = WRITE_STRATEGY_RS_INSERT_DEFAULT_IF_ABSENT;
+    } else if (writeStrategyStr == "UpdateDifferentValues") {
+      writeStrategy = WRITE_STRATEGY_RS_UPDATE_DIFFERENT_VALUES;
+    } else {
+      throw std::invalid_argument("Invalid write strategy");
+    }
+    
+    std::string log_hint_str = jsTypedArrayToCString(runtime, arguments[4]);
+    const char *log_hint = log_hint_str.c_str();
+    
+    CWriteTransaction_t *writeTransaction = jsPointerObjectToCPointer<CWriteTransaction_t>(runtime, arguments[5]);
+    
+    DocIdResult_t res = ::ditto_collection_insert_value(ditto, collectionName, docCbor, writeStrategy, log_hint, writeTransaction);
+    
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status_code));
+    obj.setProperty(runtime, "id", pointerToHexString(res.id.ptr));
+    return obj;
+  });
+}
+}

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

@@ -0,0 +1,123 @@
+#include "Utils.h"
+#include "ConnectionRequest.h"
+#include <unordered_map>
+
+namespace sharedjsi
+{
+
+Function dittoffi_connection_request_peer_key_string(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
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    char *res = ::dittoffi_connection_request_peer_key_string(connection_request);
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+
+Function dittoffi_connection_request_peer_metadata_json(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
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    slice_ref_uint8_t res = ::dittoffi_connection_request_peer_metadata_json(connection_request);
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+
+  });
+}
+
+Function dittoffi_connection_request_identity_service_metadata_json(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
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    slice_ref_uint8_t res = ::dittoffi_connection_request_identity_service_metadata_json(connection_request);
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function dittoffi_connection_request_authorize(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
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    auto authorized_string = arguments[1].toString(runtime).utf8(runtime);
+    auto authorized = authorized_string == "Allow" ? DITTOFFI_CONNECTION_REQUEST_AUTHORIZATION_ALLOW : DITTOFFI_CONNECTION_REQUEST_AUTHORIZATION_DENY;
+
+    ::dittoffi_connection_request_authorize(connection_request, authorized);
+    return Value();
+  });
+}
+
+Function dittoffi_connection_request_connection_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
+                                          {
+    dittoffi_connection_type_t res = ::dittoffi_connection_request_connection_type(jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]));
+    
+    static const std::unordered_map<dittoffi_connection_type_t, std::string> lookup = {
+      {DITTOFFI_CONNECTION_TYPE_BLUETOOTH, "Bluetooth"},
+      {DITTOFFI_CONNECTION_TYPE_ACCESS_POINT, "AccessPoint"},
+      {DITTOFFI_CONNECTION_TYPE_P2_P_WI_FI, "P2PWiFi"},
+      {DITTOFFI_CONNECTION_TYPE_WEB_SOCKET, "WebSocket"},
+    };
+    auto it = lookup.find(res);
+    if (it != lookup.end()) {
+      return String::createFromUtf8(runtime, it->second);
+    } else {
+      throw std::invalid_argument("Invalid dittoffi_connection_type_t type");
+    }
+  });
+}
+
+Function dittoffi_connection_request_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_connection_request_free(jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+}

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

@@ -0,0 +1,256 @@
+#include <DQL.h>
+#include <dittoffi.h>
+
+#include "Arc.hpp"
+#include "Utils.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)
+{
+  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;
+    dittoffi_query_result_t *query_result = result.query_result;
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "query_result", cPointerToJSPointerObject(runtime, query_result));
+
+    jsCallback->call(runtime, obj);
+  });
+}
+}
+
+Function dittoffi_try_add_sync_subscription(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 query_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *query = query_str.c_str();
+
+    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
+    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
+
+    dittoffi_result_void_t res = ::dittoffi_try_add_sync_subscription(ditto, query, query_args_cbor);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+Function dittoffi_try_remove_sync_subscription(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 query_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *query = query_str.c_str();
+
+    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
+    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
+    dittoffi_result_void_t res = ::dittoffi_try_remove_sync_subscription(ditto, query, query_args_cbor);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+Function dittoffi_try_exec_statement(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]);
+    CWriteTransaction *writeTransaction = jsPointerObjectToCPointer<CWriteTransaction_t>(runtime, arguments[1]);
+    std::string query_vec = jsTypedArrayToCString(runtime, arguments[2]);
+    const char *query = query_vec.c_str();
+
+    std::vector<uint8_t> args_vec = jsTypedArrayToCVector(runtime, arguments[3]);
+    slice_ref_uint8_t args_cbor = borrowVecAsOptRefSlice(args_vec);
+    dittoffi_result_dittoffi_query_result_ptr res = ::dittoffi_try_exec_statement(ditto, writeTransaction, query, args_cbor);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+Function dittoffi_try_experimental_register_change_observer_str_detached(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 query_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *query = query_str.c_str();
+
+    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
+    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
+
+    Function jsCallback = arguments[3].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(jsCallback));
+
+    LiveQueryAvailability lq_availability = LIVE_QUERY_AVAILABILITY_ALWAYS;
+    //    std::string lq_availability_str = arguments[3].getString(runtime).utf8(runtime);
+    //    if (lq_availability_str == "Always") {
+    //      lq_availability = LIVE_QUERY_AVAILABILITY_ALWAYS;
+    //    } if (lq_availability_str == "WhenSignalled") {
+    //      lq_availability = LIVE_QUERY_AVAILABILITY_WHEN_SIGNALLED;
+    //    } else {
+    //      throw std::invalid_argument("Invalid live query string");
+    //    }
+
+    dittoffi_result_int64_t res = ::dittoffi_try_experimental_register_change_observer_str(
+                                                                                           ditto,
+                                                                                           query,
+                                                                                           query_args_cbor,
+                                                                                           lq_availability,
+                                                                                           Arc<Function>::as_raw(wrappedStateFfiWrapper),
+                                                                                           v_retain,
+                                                                                           v_release,
+                                                                                           v_change_handler_with_query_result);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", int64ToBigIntOrNumber(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+
+Function dittoffi_query_result_item_count(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
+                                          {
+    size_t res = ::dittoffi_query_result_item_count(jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]));
+    return static_cast<double>(res);
+  });
+}
+
+
+Function dittoffi_query_result_item_at(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_query_result *dql_response = jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]);
+    size_t idx = arguments[1].asNumber();
+
+    dittoffi_query_result_item_t *res = ::dittoffi_query_result_item_at(dql_response, idx);
+    return cPointerToJSPointerObject(runtime, res);
+  });
+}
+
+Function dittoffi_query_result_mutated_document_id_count(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
+                                          {
+    size_t res = ::dittoffi_query_result_mutated_document_id_count(jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]));
+    return static_cast<double>(res);
+  });
+}
+
+Function dittoffi_query_result_mutated_document_id_at(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_query_result *dql_response = jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]);
+    size_t idx = arguments[1].asNumber();
+
+    slice_boxed_uint8_t res = ::dittoffi_query_result_mutated_document_id_at(dql_response, idx);
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function dittoffi_query_result_item_cbor(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    slice_boxed_uint8_t res = ::dittoffi_query_result_item_cbor(jsPointerObjectToCPointer<dittoffi_query_result_item_t>(runtime, arguments[0]));
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function dittoffi_query_result_item_json(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_query_result_item_json(jsPointerObjectToCPointer<dittoffi_query_result_item_t>(runtime, arguments[0]));
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+}