@dittolive/ditto 4.5.4-alpha.1 → 4.6.0

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

@@ -1,9 +1,52 @@
 #include "Utils.h"
 
 #include <Attachment.h>
+#include <Arc.hpp>
 
 namespace sharedjsi
 {
+
+DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
+
+class AttachmentResolver {
+public:
+  Function onCompleteCb;
+  Function onProgressCb;
+  Function onDeletedCb;
+
+  AttachmentResolver(Function onComplete, Function onProgress, Function onDeleted)
+  : onCompleteCb(std::move(onComplete)), onDeletedCb(std::move(onDeleted)), onProgressCb(std::move(onProgress)) {}
+};
+
+extern "C" {
+void v_on_complete(void *ctx, AttachmentHandle_t *handle)
+{
+  ditto_enqueue_call([=](Runtime *jsi) {
+    auto jsObject = reinterpret_cast<AttachmentResolver *>(ctx);
+    Runtime &runtime = *jsi;
+    jsObject->onCompleteCb.call(runtime, cPointerToJSPointerObject<AttachmentHandle>(runtime, handle));
+  });
+}
+
+void v_on_progress(void *ctx, uint64_t downloaded, uint64_t to_download)
+{
+  ditto_enqueue_call([=](Runtime *jsi) {
+    auto jsObject = reinterpret_cast<AttachmentResolver *>(ctx);
+    Runtime &runtime = *jsi;
+    jsObject->onProgressCb.call(runtime, BigInt::fromUint64(runtime, downloaded), BigInt::fromUint64(runtime, to_download));
+  });
+}
+
+void v_on_deleted(void *ctx)
+{
+  ditto_enqueue_call([=](Runtime *jsi) {
+    auto jsObject = reinterpret_cast<AttachmentResolver *>(ctx);
+    Runtime &runtime = *jsi;
+    jsObject->onDeletedCb.call(runtime);
+  });
+}
+}
+
 Function ditto_cancel_resolve_attachment(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
@@ -18,11 +61,10 @@ Function ditto_cancel_resolve_attachment(Runtime &runtime)
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
     std::vector<uint8_t> id_vec = jsTypedArrayToCVector(runtime, arguments[1]);
     slice_ref_uint8_t id = borrowVecAsOptRefSlice(id_vec);
-    
-    uint64_t cancelToken = arguments[2].asNumber();
-    
-    ::ditto_cancel_resolve_attachment(ditto, id, cancelToken);
-    return Value();
+
+    uint64_t cancelToken = arguments[2].asBigInt(runtime).asInt64(runtime);
+
+    return static_cast<double>(::ditto_cancel_resolve_attachment(ditto, id, cancelToken));
   });
 }
 
@@ -42,6 +84,52 @@ Function ditto_free_attachment_handle(Runtime &runtime)
   });
 }
 
+Function ditto_get_attachment_status(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> id_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t id = borrowVecAsRefSlice(id_vec);
+
+    AttachmentHandleResult_t res = ::ditto_get_attachment_status(ditto, id);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status_code));
+    obj.setProperty(runtime, "handle", cPointerToJSPointerObject<AttachmentHandle_t>(runtime, res.handle));
+    return obj;
+  });
+}
+
+Function ditto_get_complete_attachment_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]);
+    AttachmentHandle_t* handle = jsPointerObjectToCPointer<AttachmentHandle_t>(runtime, arguments[1]);
+    AttachmentDataResult_t res = ::ditto_get_complete_attachment_data(ditto, handle);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status));
+    obj.setProperty(runtime, "data", cSlicedBoxToJSSlicedBox(runtime, res.data));
+    return obj;
+  });
+}
+
 Function ditto_get_complete_attachment_path(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
@@ -55,9 +143,9 @@ Function ditto_get_complete_attachment_path(Runtime &runtime)
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
     AttachmentHandle_t *attachmentHandler = jsPointerObjectToCPointer<AttachmentHandle_t>(runtime, arguments[1]);
-    
-    ::ditto_get_complete_attachment_path(ditto, attachmentHandler);
-    return Value();
+
+    char *res = ::ditto_get_complete_attachment_path(ditto, attachmentHandler);
+    return cPointerToJSPointerObject<char>(runtime, res);
   });
 }
 
@@ -74,13 +162,112 @@ Function ditto_new_attachment_from_bytes(Runtime &runtime)
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
     std::vector<uint8_t> bytes_vec = jsTypedArrayToCVector(runtime, arguments[1]);
-    slice_ref_uint8_t bytes = borrowVecAsOptRefSlice(bytes_vec);
-    CAttachment_t * out_attachment = jsPointerObjectToCPointer<CAttachment_t>(runtime, arguments[2]);
-    
-    ::ditto_new_attachment_from_bytes(ditto, bytes, out_attachment);
-    return Value();
+    slice_ref_uint8_t bytes = borrowVecAsRefSlice(bytes_vec);
+
+    CAttachment_t c_attachment;
+    uint32_t res = ::ditto_new_attachment_from_bytes(ditto, bytes, &c_attachment);
+
+    if (res != 0) {
+      // It failed, bubble up the error.
+      return static_cast<double>(res);
+    }
+
+    Object const& attachment = arguments[2].getObject(runtime);
+
+    attachment.setProperty(runtime, "len", BigInt::fromUint64(runtime , c_attachment.len));
+    // Factor this out as: cSliceToUInt8Array()
+    std::vector<uint8_t> id(c_attachment.id.ptr, c_attachment.id.ptr + c_attachment.id.len);
+    TypedArray<TypedArrayKind::Uint8Array> typedArray(runtime, id);
+    attachment.setProperty(runtime, "id", typedArray);
+    attachment.setProperty(runtime, "handle", cPointerToJSPointerObject(runtime, c_attachment.handle));
+
+    return 0;
   });
 }
 
+Function ditto_new_attachment_from_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
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    std::string source_path_str = jsTypedArrayToCString(runtime, arguments[1]);
+    std::string file_operation_str = arguments[2].toString(runtime).utf8(runtime);
+
+    AttachmentFileOperation_t file_operation;
+    if (file_operation_str == "Copy") {
+      file_operation = ATTACHMENT_FILE_OPERATION_COPY;
+    } else if (file_operation_str == "Move") {
+      file_operation = ATTACHMENT_FILE_OPERATION_MOVE;
+    } else {
+      throw "Invalid attachment file operation.";
+    }
+
+    CAttachment_t c_attachment;
+    uint32_t res = ::ditto_new_attachment_from_file(ditto, source_path_str.c_str(), file_operation, &c_attachment);
+
+    if (res != 0) {
+      // It failed, bubble up the error.
+      return static_cast<double>(res);
+    }
 
+    Object const& attachment = arguments[3].getObject(runtime);
+
+    attachment.setProperty(runtime, "len", BigInt::fromUint64(runtime, c_attachment.len));
+    // Factor this out as: cSliceToUInt8Array()
+    std::vector<uint8_t> id(c_attachment.id.ptr, c_attachment.id.ptr + c_attachment.id.len);
+    TypedArray<TypedArrayKind::Uint8Array> typedArray(runtime, id);
+    attachment.setProperty(runtime, "id", typedArray);
+    attachment.setProperty(runtime, "handle", cPointerToJSPointerObject(runtime, c_attachment.handle));
+
+    return 0;
+  });
+}
+
+Function ditto_resolve_attachment(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> id_vec = jsTypedArrayToCVector(runtime, arguments[1]);
+    slice_ref_uint8_t id = borrowVecAsRefSlice(id_vec);
+
+    Function onCompleteCallback = arguments[2].getObject(runtime).getFunction(runtime);
+    Function onProgressCallback = arguments[3].getObject(runtime).getFunction(runtime);
+    Function onDeleteCallback = arguments[4].getObject(runtime).getFunction(runtime);
+
+    AttachmentResolver resolver(std::move(onCompleteCallback),
+                                std::move(onProgressCallback),
+                                std::move(onDeleteCallback));
+    Arc<AttachmentResolver> wrappedStateFfiWrapper(std::move(resolver));
+
+    CancelTokenResult_t res = ::ditto_resolve_attachment(ditto,
+                                                         id,
+                                                         Arc<AttachmentResolver>::into_raw(std::move(wrappedStateFfiWrapper)),
+                                                         nullptr,
+                                                         nullptr,
+                                                         v_on_complete,
+                                                         v_on_progress,
+                                                         v_on_deleted);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "status_code", static_cast<double>(res.status_code));
+    obj.setProperty(runtime, "cancel_token", BigInt::fromInt64(runtime, res.cancel_token));
+    return obj;
+  });
+}
 }

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

@@ -92,7 +92,7 @@ Function ditto_auth_client_get_app_id(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     char *appId = ::ditto_auth_client_get_app_id(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return String::createFromUtf8(runtime, appId);
+    return cPointerToJSPointerObject<char>(runtime, appId);
   });
 }
 
@@ -108,7 +108,7 @@ Function ditto_auth_client_get_site_id(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     uint64_t siteId = ::ditto_auth_client_get_site_id(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return static_cast<double>(siteId);
+    return BigInt::fromUint64(runtime, siteId);
   });
 }
 
@@ -221,7 +221,7 @@ Function ditto_auth_client_user_id(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     char *res = ::ditto_auth_client_user_id(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return String::createFromUtf8(runtime, res ? res : "");
+    return cPointerToJSPointerObject<char>(runtime, res);
   });
 }
 }

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

@@ -18,7 +18,7 @@ void v_change_handler_with_query_result(void *ctx, ChangeHandlerWithQueryResult_
   Arc<Function> jsCallback /* = */ (borrowedJsCallback);
   ditto_enqueue_call([=](Runtime *jsi) {
     Runtime &runtime = *jsi;
-    CDqlResponse_t *query_result = result.query_result;
+    dittoffi_query_result_t *query_result = result.query_result;
 
     Object obj(runtime);
     obj.setProperty(runtime, "query_result", cPointerToJSPointerObject(runtime, query_result));
@@ -28,7 +28,7 @@ void v_change_handler_with_query_result(void *ctx, ChangeHandlerWithQueryResult_
 }
 }
 
-Function dittoffi_try_experimental_add_dql_subscription(Runtime &runtime)
+Function dittoffi_try_add_sync_subscription(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -46,7 +46,7 @@ Function dittoffi_try_experimental_add_dql_subscription(Runtime &runtime)
     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_experimental_add_dql_subscription(ditto, query, query_args_cbor);
+    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));
@@ -54,7 +54,7 @@ Function dittoffi_try_experimental_add_dql_subscription(Runtime &runtime)
   });
 }
 
-Function dittoffi_try_experimental_remove_dql_subscription(Runtime &runtime)
+Function dittoffi_try_remove_sync_subscription(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -71,7 +71,7 @@ Function dittoffi_try_experimental_remove_dql_subscription(Runtime &runtime)
 
     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_experimental_remove_dql_subscription(ditto, query, query_args_cbor);
+    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));
@@ -79,7 +79,7 @@ Function dittoffi_try_experimental_remove_dql_subscription(Runtime &runtime)
   });
 }
 
-Function dittoffi_try_experimental_exec_statement_str(Runtime &runtime)
+Function dittoffi_try_exec_statement(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
@@ -97,7 +97,7 @@ Function dittoffi_try_experimental_exec_statement_str(Runtime &runtime)
 
     std::vector<uint8_t> args_vec = jsTypedArrayToCVector(runtime, arguments[3]);
     slice_ref_uint8_t args_cbor = borrowVecAsOptRefSlice(args_vec);
-    dittoffi_result_CDqlResponse_ptr res = ::dittoffi_try_experimental_exec_statement_str(ditto, writeTransaction, query, args_cbor);
+    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));
@@ -147,14 +147,14 @@ Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime
                                                                                            v_change_handler_with_query_result);
 
     Object obj(runtime);
-    obj.setProperty(runtime, "success", static_cast<double>(res.success));
+    obj.setProperty(runtime, "success", BigInt::fromInt64(runtime, res.success));
     obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
     return obj;
   });
 }
 
 
-Function ditto_dql_response_result_count(Runtime &runtime)
+Function dittoffi_query_result_item_count(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
@@ -164,13 +164,13 @@ Function ditto_dql_response_result_count(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
-    size_t res = ::ditto_dql_response_result_count(jsPointerObjectToCPointer<CDqlResponse>(runtime, arguments[0]));
+    size_t res = ::dittoffi_query_result_item_count(jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]));
     return static_cast<double>(res);
   });
 }
 
 
-Function ditto_dql_response_result_at(Runtime &runtime)
+Function dittoffi_query_result_item_at(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
@@ -181,15 +181,15 @@ Function ditto_dql_response_result_at(Runtime &runtime)
                                              size_t count) -> Value
                                           {
 
-    CDqlResponse *dql_response = jsPointerObjectToCPointer<CDqlResponse>(runtime, arguments[0]);
+    dittoffi_query_result *dql_response = jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]);
     size_t idx = arguments[1].asNumber();
 
-    CDqlResult_t *res = ::ditto_dql_response_result_at(dql_response, idx);
+    dittoffi_query_result_item_t *res = ::dittoffi_query_result_item_at(dql_response, idx);
     return cPointerToJSPointerObject(runtime, res);
   });
 }
 
-Function ditto_dql_response_affected_document_id_count(Runtime &runtime)
+Function dittoffi_query_result_mutated_document_id_count(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
@@ -199,12 +199,12 @@ Function ditto_dql_response_affected_document_id_count(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
-    size_t res = ::ditto_dql_response_affected_document_id_count(jsPointerObjectToCPointer<CDqlResponse>(runtime, arguments[0]));
+    size_t res = ::dittoffi_query_result_mutated_document_id_count(jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]));
     return static_cast<double>(res);
   });
 }
 
-Function ditto_dql_response_affected_document_id_at(Runtime &runtime)
+Function dittoffi_query_result_mutated_document_id_at(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
@@ -215,15 +215,15 @@ Function ditto_dql_response_affected_document_id_at(Runtime &runtime)
                                              size_t count) -> Value
                                           {
 
-    CDqlResponse *dql_response = jsPointerObjectToCPointer<CDqlResponse>(runtime, arguments[0]);
+    dittoffi_query_result *dql_response = jsPointerObjectToCPointer<dittoffi_query_result>(runtime, arguments[0]);
     size_t idx = arguments[1].asNumber();
 
-    slice_boxed_uint8_t res = ::ditto_dql_response_affected_document_id_at(dql_response, idx);
+    slice_boxed_uint8_t res = ::dittoffi_query_result_mutated_document_id_at(dql_response, idx);
     return cSlicedBoxToJSSlicedBox(runtime, res);
   });
 }
 
-Function ditto_result_cbor(Runtime &runtime)
+Function dittoffi_query_result_item_cbor(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
@@ -233,12 +233,12 @@ Function ditto_result_cbor(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
-    slice_boxed_uint8_t res = ::ditto_result_cbor(jsPointerObjectToCPointer<CDqlResult_t>(runtime, arguments[0]));
+    slice_boxed_uint8_t res = ::dittoffi_query_result_item_cbor(jsPointerObjectToCPointer<dittoffi_query_result_item_t>(runtime, arguments[0]));
     return cSlicedBoxToJSSlicedBox(runtime, res);
   });
 }
 
-Function ditto_result_json(Runtime &runtime)
+Function dittoffi_query_result_item_json(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
@@ -249,8 +249,8 @@ Function ditto_result_json(Runtime &runtime)
                                              size_t count) -> Value
                                           {
 
-    char *res = ::ditto_result_json(jsPointerObjectToCPointer<CDqlResult_t>(runtime, arguments[0]));
-    return String::createFromUtf8(runtime, res);
+    char *res = ::dittoffi_query_result_item_json(jsPointerObjectToCPointer<dittoffi_query_result_item_t>(runtime, arguments[0]));
+    return cPointerToJSPointerObject<char>(runtime, res);
   });
 }
 }

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

@@ -52,10 +52,10 @@ Function ditto_document_id_query_compatible(Runtime &runtime)
                                              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") {
@@ -65,9 +65,9 @@ Function ditto_document_id_query_compatible(Runtime &runtime)
     } else {
       throw std::invalid_argument("Invalid string primitive format.");
     }
-    
+
     char *res = ::ditto_document_id_query_compatible(id, stringPrimitiveFormat);
-    return String::createFromUtf8(runtime, res);
+    return cPointerToJSPointerObject<char>(runtime, res);
   });
 }
 
@@ -85,7 +85,7 @@ Function ditto_document_get_cbor_with_path_type(Runtime &runtime) {
     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},
@@ -104,7 +104,7 @@ Function ditto_document_get_cbor_with_path_type(Runtime &runtime) {
       {"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()) {
@@ -112,9 +112,9 @@ Function ditto_document_get_cbor_with_path_type(Runtime &runtime) {
     } 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));
@@ -134,10 +134,10 @@ Function ditto_validate_document_id(Runtime &runtime)
                                              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/FFIUtils.cpp

@@ -0,0 +1,64 @@
+#include "FFIUtils.h"
+#include <Utils.h>
+
+namespace sharedjsi
+{
+
+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]));
+  });
+}
+
+Function boxCStringIntoString(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 = jsPointerObjectToCPointer<char>(runtime, arguments[0]);
+    if (str) {
+      String res = String::createFromUtf8(runtime, str);
+      ::ditto_c_string_free(str);
+      return res;
+    } else {
+      return Value::null();
+    }
+  });
+}
+
+Function withOutBoxCBytes(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 callback = arguments[0].asObject(runtime).asFunction(runtime);
+    slice_boxed_uint8 box_c_bytes = { 0 };
+    auto out_box_cbytes = &box_c_bytes;
+    auto out_box_cbytes_js = cPointerToJSPointerObject<slice_boxed_uint8>(runtime, out_box_cbytes);
+
+    callback.call(runtime, out_box_cbytes_js);
+
+    return cSlicedBoxToJSSlicedBox(runtime, box_c_bytes);
+  });
+}
+
+}

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

@@ -0,0 +1,35 @@
+#include "Utils.h"
+
+#include <Misc.h>
+#include <fstream>
+
+namespace sharedjsi
+{
+
+Function readFile(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 filePath = arguments[0].asString(runtime).utf8(runtime);
+    try {
+      std::ifstream fileStream(filePath, std::ios::binary);
+      if (!fileStream.is_open()) {
+        throw std::runtime_error("Cannot open file: " + filePath);
+      }
+
+      // Read the file into a vector
+      std::vector<uint8_t> buffer((std::istreambuf_iterator<char>(fileStream)), std::istreambuf_iterator<char>());
+      return TypedArray<TypedArrayKind::Uint8Array>(runtime, buffer);
+    } catch (const std::exception& e) {
+      throw JSError(runtime, e.what());
+    }
+  });
+}
+}

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

@@ -7,7 +7,7 @@ namespace sharedjsi
 
 Object convertConfigResultToJSIObject(Runtime &runtime, IdentityConfigResult_t result) {
   Object obj(runtime);
-  obj.setProperty(runtime, "status_code", (double)result.status_code);
+  obj.setProperty(runtime, "status_code", static_cast<double>(result.status_code));
   obj.setProperty(runtime, "identity_config", cPointerToJSPointerObject(runtime, result.identity_config));
   return obj;
 }
@@ -49,7 +49,7 @@ Function ditto_identity_config_make_offline_playground(Runtime &runtime)
                                           {
     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();
+    uint64_t site_id = arguments[1].asBigInt(runtime).asUint64(runtime);
 
     IdentityConfigResult_t config_result = ::ditto_identity_config_make_offline_playground(app_id, site_id);
     return convertConfigResultToJSIObject(runtime, config_result);
@@ -92,7 +92,7 @@ Function ditto_identity_config_make_shared_key(Runtime &runtime)
     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();
+    uint64_t site_id = arguments[2].asBigInt(runtime).asUint64(runtime);
 
     IdentityConfigResult_t config_result = ::ditto_identity_config_make_shared_key(app_id, shared_key, site_id);
     return convertConfigResultToJSIObject(runtime, config_result);