@amazon-devices/expo-file-system 2.0.1758683737

package/kepler/ExponentFileSystem.cpp

@@ -0,0 +1,498 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "ExponentFileSystem.h"
+
+#include <JsonContainer/JsonContainer.h>
+#include <KeplerScript/logger/KPLog.h>
+#include <KeplerScript/utils/KeplerPath.h>
+#include <openssl/evp.h>
+#include <openssl/md5.h>
+#include <sys/stat.h>
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+namespace {
+std::string md5Hash(const std::string& content) {
+    std::unique_ptr<EVP_MD_CTX, decltype(&::EVP_MD_CTX_free)> context(EVP_MD_CTX_new(), ::EVP_MD_CTX_free);
+    const EVP_MD* md = EVP_md5();
+    unsigned char md_value[EVP_MAX_MD_SIZE];
+    unsigned int md_len;
+
+    EVP_DigestInit_ex2(context.get(), md, NULL);
+    EVP_DigestUpdate(context.get(), content.data(), content.length());
+    EVP_DigestFinal_ex(context.get(), md_value, &md_len);
+
+    std::string output(std::string(md_len * 2, '\0'));
+    for (size_t i = 0; i < md_len; ++i)
+        std::sprintf(&output[i * 2], "%02x", md_value[i]);
+
+    return output;
+}
+
+std::string base64Encode(const std::string& input) {
+    const auto base64Length = 4 * ((input.size() + 2) / 3);
+    std::vector<unsigned char> base64(base64Length + 1);
+    const auto encodedLength =
+            EVP_EncodeBlock(base64.data(), reinterpret_cast<const unsigned char*>(input.data()), input.size());
+    if (base64Length != encodedLength) {
+        throw std::runtime_error(
+                std::string("Expected and encoded length differ: expected: ") + std::to_string(base64Length) +
+                ", encoded: " + std::to_string(encodedLength));
+    }
+    return std::string(base64.begin(), base64.end());
+}
+
+template<typename T>
+T getOrDefault(volta::react::NativeJSObject map, std::string key, const T& defaultValue) {
+    if (map.count(key)) {
+        return std::get<T>(map[key]);
+    }
+    return defaultValue;
+}
+}  // namespace
+
+ExponentFileSystem::ExponentFileSystem() : volta::react::KeplerTurboModule("ExponentFileSystem") {
+    volta::react::KPLog.debug("ExponentFileSystem constructor {}", name());
+};
+
+/**
+ * @brief Returns "/data" - when called within an app with eg. id "com.amazon.keplerscript.expodemosapp" present in
+ * manifest.toml - it's considered as /home/app_user/packages/com.amazon.keplerscript.expodemosapp/data.
+ */
+std::string ExponentFileSystem::documentDirectory() {
+    return std::filesystem::absolute("data");
+};
+
+std::string ExponentFileSystem::cacheDirectory() {
+    return std::filesystem::absolute("cache");
+};
+
+std::string ExponentFileSystem::bundleDirectory() {
+    return volta::react::KeplerPath::getPath(volta::react::KeplerPathKind::JavaScriptBundle);
+};
+
+volta::react::Promise ExponentFileSystem::getInfoAsync(
+        const std::string fileUri,
+        volta::react::NativeJSObject options) {
+    bool shouldIncludeFileSize = getOrDefault(options, "size", false);
+    bool shouldIncludeMD5Hash = getOrDefault(options, "md5", false);
+
+    return volta::react::Promise([this, fileUri, shouldIncludeFileSize, shouldIncludeMD5Hash](
+                                         std::shared_ptr<volta::react::Promise> promise) {
+        bool exists = std::filesystem::exists(fileUri);
+
+        if (!exists) {
+            promise->resolve(volta::react::NativeJSObject{{"exists", false}, {"isDirectory", false}});
+            return;
+        }
+
+        bool isDirectory = std::filesystem::is_directory(fileUri);
+
+        struct stat fileStat;
+        int status = stat(fileUri.c_str(), &fileStat);
+        if (status != 0) {
+            volta::react::KPLog.error("[ExponentFileSystem] error while obtaining information about the file!");
+            promise->reject("Error while obtaining information about the file!");
+            return;
+        }
+
+        std::uintmax_t modificationTime = fileStat.st_mtime;
+        std::uintmax_t fileSize = getSize(fileUri);
+
+        auto fileInfo = volta::react::NativeJSObject{
+                {"exists", true},
+                {"isDirectory", isDirectory},
+                {"modification", std::to_string(modificationTime)}};
+
+        if (shouldIncludeFileSize) {
+            fileInfo.insert({"size", std::to_string(fileSize)});
+        }
+
+        if (shouldIncludeMD5Hash) {
+            std::ifstream stream(fileUri);
+            volta::react::KPLog.debug("[MD5] trying to open the file: {} for read", fileUri);
+            if (stream.fail()) {
+                volta::react::KPLog.error("[MD5] unable to open file at {} for read", fileUri);
+                promise->reject("Error while trying to open the file");
+                return;
+            } else {
+                std::stringstream buffer;
+                buffer << stream.rdbuf();
+                std::string content = buffer.str();
+                volta::react::KPLog.debug("[MD5] content: {}", content);
+                volta::react::KPLog.debug("[MD5] calculating the file content hash...");
+                std::string hash = md5Hash(content);
+                volta::react::KPLog.debug("[MD5] file hash: {}", hash);
+                fileInfo.insert({"md5", hash});
+            }
+        }
+        promise->resolve(fileInfo);
+    });
+};
+
+volta::react::Promise ExponentFileSystem::readAsStringAsync(
+        const std::string fileUri,
+        volta::react::NativeJSObject options) {
+    std::string desiredEncoding = getOrDefault(options, "encoding", std::string("utf8"));
+    int bytesToSkip = int(getOrDefault(options, "position", static_cast<double>(0)));
+    int length = getOrDefault(options, "length", static_cast<double>(-1));
+
+    return volta::react::Promise(
+            [this, fileUri, desiredEncoding, bytesToSkip, length](std::shared_ptr<volta::react::Promise> promise) {
+                try {
+                    volta::react::KPLog.debug("[ExponentFileSystem] path: {}", fileUri);
+                    std::int32_t fileSize = std::filesystem::file_size(fileUri);
+
+                    std::ifstream stream(fileUri);
+                    volta::react::KPLog.debug("[ExponentFileSystem] trying to open the file: {} for read", fileUri);
+                    if (stream.fail()) {
+                        volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for read", fileUri);
+                        promise->reject("Error while trying to open the file");
+                        return;
+                    }
+
+                    if (bytesToSkip >= fileSize) {
+                        volta::react::KPLog.error("[ExponentFileSystem] cannot skip beyond end of file!");
+                        promise->reject("Cannot skip beyond end of file");
+                        return;
+                    }
+
+                    std::int32_t bytesToRead = length < 0 ? std::min(fileSize, fileSize - bytesToSkip)
+                                                          : std::min(length, fileSize - bytesToSkip);
+
+                    stream.seekg(bytesToSkip, std::ios::beg);
+                    std::string content;
+                    content.resize(bytesToRead);
+                    stream.read(&content[0], bytesToRead);
+                    volta::react::KPLog.debug("[ExponentFileSystem] content: {}", content);
+
+                    if (desiredEncoding == "base64") {
+                        volta::react::KPLog.debug("[base64] base64 encoding...");
+                        promise->resolve(base64Encode(content));
+                    } else {
+                        promise->resolve(content);
+                    }
+                } catch (std::exception& e) {
+                    volta::react::KPLog.error("[ExponentFileSystem] reading file exception reason: {}", e.what());
+                    promise->reject(e.what());
+                }
+            });
+};
+
+volta::react::Promise ExponentFileSystem::getContentUriAsync(const std::string fileUri) {
+    return volta::react::Promise([this, &fileUri](std::shared_ptr<volta::react::Promise> promise) {
+        std::string contentUri = std::filesystem::absolute(fileUri);
+
+        promise->resolve(contentUri);
+    });
+};
+
+volta::react::Promise ExponentFileSystem::writeAsStringAsync(
+        const std::string fileUri,
+        const std::string contents,
+        volta::react::NativeJSObject options) {
+    std::string desiredEncoding = getOrDefault(options, "encoding", std::string("utf8"));
+
+    return volta::react::Promise(
+            [this, fileUri, contents, desiredEncoding](std::shared_ptr<volta::react::Promise> promise) {
+                try {
+                    std::ofstream stream(fileUri);
+                    volta::react::KPLog.debug("[ExponentFileSystem] trying to open the file: {} for write", fileUri);
+                    if (stream.fail()) {
+                        volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for write", fileUri);
+                        promise->reject("Error while trying to open the file");
+                        return;
+                    } else {
+                        if (desiredEncoding == "base64") {
+                            stream << base64Encode(contents);
+                        } else {
+                            stream << contents;
+                        }
+
+                        if (stream.fail()) {
+                            volta::react::KPLog.error("[ExponentFileSystem] error while writing to file");
+                            promise->reject("Error while trying to write to the file");
+                            return;
+                        }
+                        stream.close();
+                    }
+                    promise->resolve();
+                } catch (std::exception& e) {
+                    volta::react::KPLog.error("[ExponentFileSystem] writing file exception reason: {}", e.what());
+                    promise->reject(e.what());
+                }
+            });
+};
+
+volta::react::Promise ExponentFileSystem::writeArrayBufferAsync(
+        const std::string fileUri,
+        const volta::react::ArrayBuffer arrayBuffer) {
+    return volta::react::Promise([this, fileUri, arrayBuffer](std::shared_ptr<volta::react::Promise> promise) {
+        try {
+            std::ofstream file(fileUri, std::ios::binary);
+            std::shared_ptr<std::vector<uint8_t>> dataPtr = arrayBuffer.dataVector();
+
+            if (file.fail()) {
+                volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for response write", fileUri);
+                promise->reject("File while tring to open the file");
+                return;
+            } else {
+                if (dataPtr && !dataPtr->empty()) {
+                    file.write(reinterpret_cast<const char*>(dataPtr->data()), dataPtr->size());
+                    if (file.fail()) {
+                        volta::react::KPLog.error("[ExponentFileSystem] error while writing response to file");
+                        promise->reject("Error while trying to write response to file");
+                        return;
+                    }
+                }
+            }
+            promise->resolve();
+        } catch (std::exception& e) {
+            volta::react::KPLog.error("[ExponentFileSystem] writing file exception reason: {}", e.what());
+            promise->reject(e.what());
+        }
+    });
+}
+
+volta::react::Promise ExponentFileSystem::deleteAsync(const std::string fileUri, volta::react::NativeJSObject options) {
+    bool idempotent = getOrDefault(options, "idempotent", false);
+
+    return volta::react::Promise([this, fileUri, idempotent](std::shared_ptr<volta::react::Promise> promise) {
+        if (!std::filesystem::exists(fileUri)) {
+            if (idempotent) {
+                promise->resolve();
+                return;
+            } else {
+                volta::react::KPLog.error("[ExponentFileSystem] file does not exist at the specified URI!");
+                promise->reject("File does not exist at the specified URI");
+                return;
+            }
+        }
+
+        if (std::filesystem::is_regular_file(fileUri)) {
+            try {
+                std::filesystem::remove(fileUri);
+                promise->resolve();
+            } catch (std::filesystem::filesystem_error& e) {
+                volta::react::KPLog.error("[ExponentFileSystem] file deletion exception, reason: {}", e.what());
+                promise->reject(e.what());
+            }
+        } else {
+            volta::react::KPLog.error("[ExponentFileSystem] resource is not a regular file!");
+            promise->reject("Resource is not a regular file");
+        }
+    });
+};
+
+volta::react::Promise ExponentFileSystem::moveAsync(volta::react::NativeJSObject options) {
+    std::string from = getOrDefault(options, "from", std::string(""));
+    std::string to = getOrDefault(options, "to", std::string(""));
+
+    return volta::react::Promise([this, from, to](std::shared_ptr<volta::react::Promise> promise) {
+        if (from.empty() || to.empty()) {
+            volta::react::KPLog.error(
+                    "[ExponentFileSystem]::moveAsync 'from' or 'to' not provided but they are both required");
+            promise->reject("'from' or 'to' not provided but they are both required");
+            return;
+        }
+
+        try {
+            std::filesystem::rename(from, to);
+            promise->resolve();
+        } catch (std::filesystem::filesystem_error& e) {
+            volta::react::KPLog.error("[ExponentFileSystem] file transfer exception, reason: {}", e.what());
+            promise->reject(e.what());
+        }
+    });
+};
+
+volta::react::Promise ExponentFileSystem::copyAsync(volta::react::NativeJSObject options) {
+    std::string from = getOrDefault(options, "from", std::string(""));
+    std::string to = getOrDefault(options, "to", std::string(""));
+
+    return volta::react::Promise([this, from, to](std::shared_ptr<volta::react::Promise> promise) {
+        if (from.empty() || to.empty()) {
+            volta::react::KPLog.error(
+                    "[ExponentFileSystem]::copyAsync 'from' or 'to' not provided but they are both required");
+            promise->reject("'from' or 'to' not provided but they are both required");
+            return;
+        }
+
+        try {
+            std::filesystem::copy(from, to, std::filesystem::copy_options::recursive);
+            promise->resolve();
+        } catch (std::filesystem::filesystem_error& e) {
+            volta::react::KPLog.error("[ExponentFileSystem] file transfer exception, reason: {}", e.what());
+            promise->reject(e.what());
+        }
+    });
+};
+
+volta::react::Promise ExponentFileSystem::makeDirectoryAsync(
+        const std::string fileUri,
+        volta::react::NativeJSObject options) {
+    bool idempotent = getOrDefault(options, "intermediates", false);
+
+    return volta::react::Promise([this, fileUri, idempotent](std::shared_ptr<volta::react::Promise> promise) {
+        try {
+            bool exists = std::filesystem::exists(fileUri);
+
+            if (exists) {
+                if (idempotent) {
+                    promise->resolve();
+                    return;
+                }
+                volta::react::KPLog.error("[ExponentFileSystem] directory already exists!");
+                promise->reject("Directory already exists");
+                return;
+            }
+
+            std::error_code errorCode;
+
+            if (std::filesystem::create_directories(fileUri, errorCode)) {
+                volta::react::KPLog.debug("[ExponentFileSystem] directory created successfully!");
+            } else {
+                volta::react::KPLog.error(
+                        "[ExponentFileSystem] directory creation failed, message: {}",
+                        errorCode.message());
+                promise->reject(errorCode.message());
+                return;
+            }
+            promise->resolve();
+        } catch (std::exception& e) {
+            volta::react::KPLog.error("[ExponentFileSystem] directory creation exception, reason: {}", e.what());
+            promise->reject(e.what());
+        }
+    });
+};
+
+volta::react::Promise ExponentFileSystem::readDirectoryAsync(const std::string fileUri) {
+    return volta::react::Promise([this, fileUri](std::shared_ptr<volta::react::Promise> promise) {
+        try {
+            if (!std::filesystem::exists(fileUri)) {
+                volta::react::KPLog.error("[ExponentFileSystem] directory does not exist at the specified URI!");
+                promise->reject("Directory does not exist at the specified URI");
+                return;
+            } else if (!std::filesystem::is_directory(fileUri)) {
+                volta::react::KPLog.error("[ExponentFileSystem] resource at the specified URI is not a directory!");
+                promise->reject("Resource at the specified URI is not a directory");
+                return;
+            }
+
+            auto childrenNames = volta::react::NativeJSArray{};
+
+            // Symbolic links of the directory entries are not followed
+            // during this enumeration.
+            for (auto& child : std::filesystem::directory_iterator(fileUri)) {
+                childrenNames.push_back(child.path().filename().string());
+            }
+
+            promise->resolve(childrenNames);
+        } catch (std::exception& e) {
+            volta::react::KPLog.error("[ExponentFileSystem] Reading directory exception: {}", e.what());
+            promise->reject(e.what());
+        }
+    });
+};
+
+volta::react::Promise ExponentFileSystem::getFreeDiskStorageAsync() {
+    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
+        try {
+            std::string path = std::filesystem::absolute("data");
+
+            std::error_code errorCode;
+            std::filesystem::space_info spaceInfo = std::filesystem::space(path, errorCode);
+            if (errorCode) {
+                volta::react::KPLog.error(
+                        "[ExponentFileSystem] Error when getting free disk space: {}",
+                        errorCode.message());
+                promise->reject(errorCode.message());
+                return;
+            }
+            volta::react::KPLog.debug("[ExponentFileSystem] Free space: {}", std::to_string(spaceInfo.available));
+            promise->resolve(std::to_string(spaceInfo.available));
+        } catch (std::exception& e) {
+            volta::react::KPLog.error("[ExponentFileSystem] Getting free disk storage exception: {}", e.what());
+            promise->reject(e.what());
+        }
+    });
+};
+
+volta::react::Promise ExponentFileSystem::getTotalDiskCapacityAsync() {
+    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) { promise->resolve(); });
+};
+
+volta::react::Promise ExponentFileSystem::downloadAsync(
+        const std::string,
+        const std::string,
+        volta::react::NativeJSObject,
+        double,
+        std::vector<utils::json::JsonContainer>) {
+    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
+        promise->reject("downloadAsync method has been deprecated, Update expo-file-system npm package");
+    });
+};
+
+volta::react::Promise ExponentFileSystem::uploadAsync(
+        const std::string,
+        const std::string,
+        volta::react::NativeJSObject,
+        double,
+        std::vector<utils::json::JsonContainer>) {
+    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
+        promise->reject("uploadAsync method has been deprecated, Update expo-file-system npm package");
+    });
+};
+
+std::uintmax_t ExponentFileSystem::getSize(const std::string& path) {
+    if (std::filesystem::is_regular_file(path)) {
+        return std::filesystem::file_size(path);
+    }
+
+    std::uintmax_t totalSize = DIRECTORY_SIZE;
+    for (const auto& file : std::filesystem::recursive_directory_iterator(
+                 path,
+                 std::filesystem::directory_options::follow_directory_symlink)) {
+        if (std::filesystem::is_regular_file(file)) {
+            totalSize += std::filesystem::file_size(file);
+        } else {
+            totalSize += DIRECTORY_SIZE;
+        }
+    }
+
+    return totalSize;
+};
+
+void ExponentFileSystem::aggregateMethods(
+        volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept {
+    volta::react::KPLog.debug("methodAggregator");
+
+    methodAggregator.addMethod("documentDirectory", 0, &ExponentFileSystem::documentDirectory);
+    methodAggregator.addMethod("cacheDirectory", 0, &ExponentFileSystem::cacheDirectory);
+    methodAggregator.addMethod("bundleDirectory", 0, &ExponentFileSystem::bundleDirectory);
+    methodAggregator.addMethod("getInfoAsync", 2, &ExponentFileSystem::getInfoAsync);
+    methodAggregator.addMethod("readAsStringAsync", 2, &ExponentFileSystem::readAsStringAsync);
+    methodAggregator.addMethod("getContentUriAsync", 1, &ExponentFileSystem::getContentUriAsync);
+    methodAggregator.addMethod("writeAsStringAsync", 3, &ExponentFileSystem::writeAsStringAsync);
+    methodAggregator.addMethod("writeArrayBufferAsync", 2, &ExponentFileSystem::writeArrayBufferAsync);
+    methodAggregator.addMethod("deleteAsync", 2, &ExponentFileSystem::deleteAsync);
+    methodAggregator.addMethod("moveAsync", 1, &ExponentFileSystem::moveAsync);
+    methodAggregator.addMethod("copyAsync", 1, &ExponentFileSystem::copyAsync);
+    methodAggregator.addMethod("makeDirectoryAsync", 2, &ExponentFileSystem::makeDirectoryAsync);
+    methodAggregator.addMethod("readDirectoryAsync", 1, &ExponentFileSystem::readDirectoryAsync);
+    methodAggregator.addMethod("getFreeDiskStorageAsync", 0, &ExponentFileSystem::getFreeDiskStorageAsync);
+    methodAggregator.addMethod("getTotalDiskCapacityAsync", 0, &ExponentFileSystem::getTotalDiskCapacityAsync);
+    methodAggregator.addMethod("downloadAsync", 5, &ExponentFileSystem::downloadAsync);
+    methodAggregator.addMethod("uploadAsync", 4, &ExponentFileSystem::uploadAsync);
+}

package/kepler/ExponentFileSystem.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+#pragma once
+
+#include <KeplerScript/modules/KeplerTurboModule.h>
+
+class KEPLERSCRIPT_EXPORT ExponentFileSystem : public volta::react::KeplerTurboModule {
+public:
+    ExponentFileSystem();
+
+#ifndef UNIT_TEST
+protected:
+#endif
+    std::string documentDirectory();
+    std::string cacheDirectory();
+    std::string bundleDirectory();
+
+    volta::react::Promise getInfoAsync(const std::string fileUri, volta::react::NativeJSObject options);
+    volta::react::Promise readAsStringAsync(const std::string fileUri, volta::react::NativeJSObject options);
+    volta::react::Promise getContentUriAsync(const std::string fileUri);
+    volta::react::Promise writeAsStringAsync(
+            const std::string fileUri,
+            const std::string contents,
+            volta::react::NativeJSObject options);
+    volta::react::Promise writeArrayBufferAsync(
+            const std::string fileUri,
+            const volta::react::ArrayBuffer arrayBuffer);
+    volta::react::Promise deleteAsync(const std::string fileUri, volta::react::NativeJSObject options);
+    volta::react::Promise moveAsync(volta::react::NativeJSObject options);
+    volta::react::Promise copyAsync(volta::react::NativeJSObject options);
+    volta::react::Promise makeDirectoryAsync(const std::string fileUri, volta::react::NativeJSObject options);
+    volta::react::Promise readDirectoryAsync(const std::string fileUri);
+    volta::react::Promise getFreeDiskStorageAsync();
+    volta::react::Promise getTotalDiskCapacityAsync();
+    volta::react::Promise downloadAsync(
+            const std::string url,
+            const std::string fileUri,
+            volta::react::NativeJSObject options,
+            double requestId,
+            std::vector<utils::json::JsonContainer> headers);
+    volta::react::Promise uploadAsync(
+            const std::string url,
+            const std::string fileUri,
+            volta::react::NativeJSObject options,
+            double requestId,
+            std::vector<utils::json::JsonContainer> headers);
+
+    void aggregateMethods(
+            volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept override;
+
+private:
+    static constexpr int DIRECTORY_SIZE = 4096;
+
+    std::uintmax_t getSize(const std::string& path);
+};

package/kepler/KeplerInit.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <KeplerScript/logger/KPLog.h>
+#include <KeplerScript/utils/autolink/KeplerAutoLinkInfo.h>
+#include <keplerui-072/keplerscript-export.h>
+
+#include "ExponentFileSystem.h"
+#include "RegisterModule.h"
+
+extern "C" {
+KEPLERSCRIPT_EXPORT void keplerAutoLinkInitV1(const kepler::autolink::v1::KeplerAutoLinkInfo* autoLinkInfo) noexcept {
+    volta::react::KPLog.debug("keplerAutoLinkInitV1 for ExponentFileSystem");
+
+    REGISTER_MODULE(autoLinkInfo, ExponentFileSystem, "ExponentFileSystem");
+
+    volta::react::KPLog.debug("after registering module");
+}
+}
+
+int main() {
+    return 0;
+}

package/kepler/NetworkingRequestHandler.cpp

@@ -0,0 +1,47 @@
+#include "NetworkingRequestHandler.h"
+
+#include <fstream>
+
+bool NetworkingRequestHandler::supports(utils::json::JsonContainer& data) {
+    return data["fileUri"].isValue();
+}
+
+void NetworkingRequestHandler::decorateRequest(
+        utils::json::JsonContainer& data,
+        const std::string& contentType,
+        volta::react::NetworkRequest& request) {
+    auto type = data["type"].getValue<std::string>("");
+
+    if (type.empty()) {
+        type = "application/octet-stream";
+    }
+
+    request.addHeader(volta::react::NetworkingModule::CONTENT_TYPE_HEADER_KEY, type);
+
+    try {
+        auto dataPtr = std::make_shared<std::vector<uint8_t>>();
+
+        auto fileUri = data["fileUri"].getValue<std::string>();
+
+        std::ifstream file(fileUri, std::ios::binary);
+
+        if (file.fail()) {
+            volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for response read", fileUri);
+        } else {
+            std::copy(
+                    std::istreambuf_iterator<char>(file),
+                    std::istreambuf_iterator<char>(),
+                    std::back_inserter(*dataPtr));
+
+            if (file.fail()) {
+                volta::react::KPLog.error("[ExponentFileSystem] error while reading response from file");
+            } else {
+                volta::react::KPLog.debug("[ExponentFileSystem] successfully read response from file");
+                volta::react::ArrayBuffer buf(dataPtr);
+                request.bodyDataBuffer = volta::react::ArrayBuffer(buf.dataVector());
+            }
+        }
+    } catch (std::exception& e) {
+        volta::react::KPLog.error("[ExponentFileSystem] reading response from file exception reason: {}", e.what());
+    }
+}