@amazon-devices/expo-file-system 2.0.1758683737

package/ios/FileSystemModule.swift

@@ -0,0 +1,263 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+private let EVENT_DOWNLOAD_PROGRESS = "expo-file-system.downloadProgress"
+private let EVENT_UPLOAD_PROGRESS = "expo-file-system.uploadProgress"
+
+public final class FileSystemModule: Module {
+  private lazy var sessionTaskDispatcher = EXSessionTaskDispatcher(sessionHandler: ExpoAppDelegate.getSubscriberOfType(FileSystemBackgroundSessionHandler.self))
+  private lazy var taskHandlersManager = EXTaskHandlersManager()
+
+  private lazy var backgroundSession = createUrlSession(type: .background, delegate: sessionTaskDispatcher)
+  private lazy var foregroundSession = createUrlSession(type: .foreground, delegate: sessionTaskDispatcher)
+
+  private var documentDirectory: URL? {
+    return appContext?.config.documentDirectory
+  }
+
+  private var cacheDirectory: URL? {
+    return appContext?.config.cacheDirectory
+  }
+
+  // swiftlint:disable:next cyclomatic_complexity
+  public func definition() -> ModuleDefinition {
+    Name("ExponentFileSystem")
+
+    Constants {
+      return [
+        "documentDirectory": documentDirectory?.absoluteString,
+        "cacheDirectory": cacheDirectory?.absoluteString,
+        "bundleDirectory": Bundle.main.bundlePath
+      ]
+    }
+
+    Events(EVENT_DOWNLOAD_PROGRESS, EVENT_UPLOAD_PROGRESS)
+
+    AsyncFunction("getInfoAsync") { (url: URL, options: InfoOptions, promise: Promise) in
+      switch url.scheme {
+      case "file":
+        EXFileSystemLocalFileHandler.getInfoForFile(url, withOptions: options.toDictionary(), resolver: promise.resolver, rejecter: promise.legacyRejecter)
+      case "assets-library", "ph":
+        EXFileSystemAssetLibraryHandler.getInfoForFile(url, withOptions: options.toDictionary(), resolver: promise.resolver, rejecter: promise.legacyRejecter)
+      default:
+        throw UnsupportedSchemeException(url.scheme)
+      }
+    }
+
+    AsyncFunction("readAsStringAsync") { (url: URL, options: ReadingOptions) -> String in
+      try ensurePathPermission(appContext, path: url.path, flag: .read)
+
+      if options.encoding == .base64 {
+        return try readFileAsBase64(path: url.path, options: options)
+      }
+      do {
+        return try String(contentsOfFile: url.path, encoding: options.encoding.toStringEncoding() ?? .utf8)
+      } catch {
+        throw FileNotReadableException(url.path)
+      }
+    }
+
+    AsyncFunction("writeAsStringAsync") { (url: URL, string: String, options: WritingOptions) in
+      try ensurePathPermission(appContext, path: url.path, flag: .write)
+
+      if options.encoding == .base64 {
+        try writeFileAsBase64(path: url.path, string: string)
+        return
+      }
+      do {
+        try string.write(toFile: url.path, atomically: true, encoding: options.encoding.toStringEncoding() ?? .utf8)
+      } catch {
+        throw FileNotWritableException(url.path)
+          .causedBy(error)
+      }
+    }
+
+    AsyncFunction("deleteAsync") { (url: URL, options: DeletingOptions) in
+      guard url.isFileURL else {
+        throw InvalidFileUrlException(url)
+      }
+      try removeFile(path: url.path, idempotent: options.idempotent)
+    }
+
+    AsyncFunction("moveAsync") { (options: RelocatingOptions) in
+      let (fromUrl, toUrl) = try options.asTuple()
+
+      guard fromUrl.isFileURL else {
+        throw InvalidFileUrlException(fromUrl)
+      }
+      guard toUrl.isFileURL else {
+        throw InvalidFileUrlException(toUrl)
+      }
+
+      try ensurePathPermission(appContext, path: fromUrl.appendingPathComponent("..").path, flag: .write)
+      try ensurePathPermission(appContext, path: toUrl.path, flag: .write)
+      try removeFile(path: toUrl.path, idempotent: true)
+      try FileManager.default.moveItem(atPath: fromUrl.path, toPath: toUrl.path)
+    }
+
+    AsyncFunction("copyAsync") { (options: RelocatingOptions, promise: Promise) in
+      let (fromUrl, toUrl) = try options.asTuple()
+
+      try ensurePathPermission(appContext, path: fromUrl.path, flag: .read)
+      try ensurePathPermission(appContext, path: toUrl.path, flag: .write)
+
+      if fromUrl.scheme == "file" {
+        EXFileSystemLocalFileHandler.copy(from: fromUrl, to: toUrl, resolver: promise.resolver, rejecter: promise.legacyRejecter)
+      } else if ["ph", "assets-library"].contains(fromUrl.scheme) {
+        EXFileSystemAssetLibraryHandler.copy(from: fromUrl, to: toUrl, resolver: promise.resolver, rejecter: promise.legacyRejecter)
+      } else {
+        throw InvalidFileUrlException(fromUrl)
+      }
+    }
+
+    AsyncFunction("makeDirectoryAsync") { (url: URL, options: MakeDirectoryOptions) in
+      guard url.isFileURL else {
+        throw InvalidFileUrlException(url)
+      }
+
+      try ensurePathPermission(appContext, path: url.path, flag: .write)
+      try FileManager.default.createDirectory(at: url, withIntermediateDirectories: options.intermediates, attributes: nil)
+    }
+
+    AsyncFunction("readDirectoryAsync") { (url: URL) -> [String] in
+      guard url.isFileURL else {
+        throw InvalidFileUrlException(url)
+      }
+      try ensurePathPermission(appContext, path: url.path, flag: .read)
+
+      return try FileManager.default.contentsOfDirectory(atPath: url.path)
+    }
+
+    AsyncFunction("downloadAsync") { (sourceUrl: URL, localUrl: URL, options: DownloadOptions, promise: Promise) in
+      try ensureFileDirectoryExists(localUrl)
+      try ensurePathPermission(appContext, path: localUrl.path, flag: .write)
+
+      let session = options.sessionType == .background ? backgroundSession : foregroundSession
+      let request = createUrlRequest(url: sourceUrl, headers: options.headers)
+      let downloadTask = session.downloadTask(with: request)
+      let taskDelegate = EXSessionDownloadTaskDelegate(
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter,
+        localUrl: localUrl,
+        shouldCalculateMd5: options.md5
+      )
+
+      sessionTaskDispatcher.register(taskDelegate, for: downloadTask)
+      downloadTask.resume()
+    }
+
+    AsyncFunction("uploadAsync") { (targetUrl: URL, localUrl: URL, options: UploadOptions, promise: Promise) in
+      guard localUrl.isFileURL else {
+        throw InvalidFileUrlException(localUrl)
+      }
+      guard FileManager.default.fileExists(atPath: localUrl.path) else {
+        throw FileNotExistsException(localUrl.path)
+      }
+      let session = options.sessionType == .background ? backgroundSession : foregroundSession
+      let task = createUploadTask(session: session, targetUrl: targetUrl, sourceUrl: localUrl, options: options)
+      let taskDelegate = EXSessionUploadTaskDelegate(resolve: promise.resolver, reject: promise.legacyRejecter)
+
+      sessionTaskDispatcher.register(taskDelegate, for: task)
+      task.resume()
+    }
+
+    AsyncFunction("uploadTaskStartAsync") { (targetUrl: URL, localUrl: URL, uuid: String, options: UploadOptions, promise: Promise) in
+      let session = options.sessionType == .background ? backgroundSession : foregroundSession
+      let task = createUploadTask(session: session, targetUrl: targetUrl, sourceUrl: localUrl, options: options)
+      let onSend: EXUploadDelegateOnSendCallback = { [weak self] _, _, totalBytesSent, totalBytesExpectedToSend in
+        self?.sendEvent(EVENT_UPLOAD_PROGRESS, [
+          "uuid": uuid,
+          "data": [
+            "totalBytesSent": totalBytesSent,
+            "totalBytesExpectedToSend": totalBytesExpectedToSend
+          ]
+        ])
+      }
+      let taskDelegate = EXSessionCancelableUploadTaskDelegate(
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter,
+        onSendCallback: onSend,
+        resumableManager: taskHandlersManager,
+        uuid: uuid
+      )
+
+      sessionTaskDispatcher.register(taskDelegate, for: task)
+      taskHandlersManager.register(task, uuid: uuid)
+      task.resume()
+    }
+
+    // swiftlint:disable:next line_length closure_body_length
+    AsyncFunction("downloadResumableStartAsync") { (sourceUrl: URL, localUrl: URL, uuid: String, options: DownloadOptions, resumeDataString: String?, promise: Promise) in
+      try ensureFileDirectoryExists(localUrl)
+      try ensurePathPermission(appContext, path: localUrl.path, flag: .write)
+
+      let session = options.sessionType == .background ? backgroundSession : foregroundSession
+      let resumeData = resumeDataString != nil ? Data(base64Encoded: resumeDataString ?? "") : nil
+      let onWrite: EXDownloadDelegateOnWriteCallback = { [weak self] _, _, totalBytesWritten, totalBytesExpectedToWrite in
+        self?.sendEvent(EVENT_DOWNLOAD_PROGRESS, [
+          "uuid": uuid,
+          "data": [
+            "totalBytesWritten": totalBytesWritten,
+            "totalBytesExpectedToWrite": totalBytesExpectedToWrite
+          ]
+        ])
+      }
+      let task: URLSessionDownloadTask
+
+      if let resumeDataString, let resumeData = Data(base64Encoded: resumeDataString) {
+        task = session.downloadTask(withResumeData: resumeData)
+      } else {
+        let request = createUrlRequest(url: sourceUrl, headers: options.headers)
+        task = session.downloadTask(with: request)
+      }
+
+      let taskDelegate = EXSessionResumableDownloadTaskDelegate(
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter,
+        localUrl: localUrl,
+        shouldCalculateMd5: options.md5,
+        onWriteCallback: onWrite,
+        resumableManager: taskHandlersManager,
+        uuid: uuid
+      )
+
+      sessionTaskDispatcher.register(taskDelegate, for: task)
+      taskHandlersManager.register(task, uuid: uuid)
+      task.resume()
+    }
+
+    AsyncFunction("downloadResumablePauseAsync") { (id: String) -> [String: String?] in
+      guard let task = taskHandlersManager.downloadTask(forId: id) else {
+        throw DownloadTaskNotFoundException(id)
+      }
+      let resumeData = await task.cancelByProducingResumeData()
+
+      return [
+        "resumeData": resumeData?.base64EncodedString()
+      ]
+    }
+
+    AsyncFunction("networkTaskCancelAsync") { (id: String) in
+      taskHandlersManager.task(forId: id)?.cancel()
+    }
+
+    AsyncFunction("getFreeDiskStorageAsync") { () -> Int in
+      let resourceValues = try getResourceValues(from: documentDirectory, forKeys: [.volumeAvailableCapacityKey])
+
+      guard let availableCapacity = resourceValues?.volumeAvailableCapacity else {
+        throw CannotDetermineDiskCapacity()
+      }
+      return availableCapacity
+    }
+
+    AsyncFunction("getTotalDiskCapacityAsync") { () -> Int in
+      let resourceValues = try getResourceValues(from: documentDirectory, forKeys: [.volumeTotalCapacityKey])
+
+      guard let totalCapacity = resourceValues?.volumeTotalCapacity else {
+        throw CannotDetermineDiskCapacity()
+      }
+      return totalCapacity
+    }
+  }
+}

package/ios/FileSystemRecords.swift

@@ -0,0 +1,74 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+struct InfoOptions: Record {
+  @Field var md5: Bool = false
+  @Field var size: Bool = false
+}
+
+struct ReadingOptions: Record {
+  @Field var encoding: Encoding = .utf8
+  @Field var position: Int?
+  @Field var length: Int?
+}
+
+struct WritingOptions: Record {
+  @Field var encoding: Encoding = .utf8
+}
+
+struct DeletingOptions: Record {
+  @Field var idempotent: Bool = false
+}
+
+struct RelocatingOptions: Record {
+  @Field var from: URL?
+  @Field var to: URL?
+
+  func asTuple() throws -> (URL, URL) {
+    guard let from, let to else {
+      let missingOptionName = from == nil ? "from" : "to"
+      throw Exception(name: "MissingParameterException", description: "Missing option '\(missingOptionName)'")
+    }
+    return (from, to)
+  }
+}
+
+struct MakeDirectoryOptions: Record {
+  @Field var intermediates: Bool = false
+}
+
+struct DownloadOptions: Record {
+  @Field var md5: Bool = false
+  @Field var cache: Bool = false
+  @Field var headers: [String: String]?
+  @Field var sessionType: SessionType = .background
+}
+
+struct UploadOptions: Record {
+  @Field var headers: [String: String]?
+  @Field var httpMethod: HttpMethod = .post
+  @Field var sessionType: SessionType = .background
+  @Field var uploadType: UploadType = .binaryContent
+
+  // Multipart
+  @Field var fieldName: String?
+  @Field var mimeType: String?
+  @Field var parameters: [String: String]?
+}
+
+enum SessionType: Int, Enumerable {
+  case background = 0
+  case foreground = 1
+}
+
+enum HttpMethod: String, Enumerable {
+  case post = "POST"
+  case put = "PUT"
+  case patch = "PATCH"
+}
+
+enum UploadType: Int, Enumerable {
+  case binaryContent = 0
+  case multipart = 1
+}

package/ios/NSData+EXFileSystem.h

@@ -0,0 +1,9 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+
+@interface NSData (EXFileSystem)
+
+- (NSString *)md5String;
+
+@end

package/ios/NSData+EXFileSystem.m

@@ -0,0 +1,19 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#import <ExpoFileSystem/NSData+EXFileSystem.h>
+#import <CommonCrypto/CommonDigest.h>
+
+@implementation NSData (EXFileSystem)
+
+- (NSString *)md5String
+{
+  unsigned char digest[CC_MD5_DIGEST_LENGTH];
+  CC_MD5(self.bytes, (CC_LONG) self.length, digest);
+  NSMutableString *md5 = [NSMutableString stringWithCapacity:2 * CC_MD5_DIGEST_LENGTH];
+  for (unsigned int i = 0; i < CC_MD5_DIGEST_LENGTH; ++i) {
+    [md5 appendFormat:@"%02x", digest[i]];
+  }
+  return md5;
+}
+
+@end

package/ios/NetworkingHelpers.swift

@@ -0,0 +1,84 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import CoreServices
+import ExpoModulesCore
+
+func findMimeType(forAttachment attachment: URL) -> String {
+  if let identifier = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, attachment.pathExtension as CFString, nil)?.takeRetainedValue() {
+    if let type = UTTypeCopyPreferredTagWithClass(identifier, kUTTagClassMIMEType)?.takeRetainedValue() {
+      return type as String
+    }
+  }
+  return "application/octet-stream"
+}
+
+func createUrlSession(type: SessionType, delegate: URLSessionDelegate) -> URLSession {
+  let configuration = type == .foreground ? URLSessionConfiguration.default : URLSessionConfiguration.background(withIdentifier: UUID().uuidString)
+  configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+  configuration.urlCache = nil
+  return URLSession(configuration: configuration, delegate: delegate, delegateQueue: .main)
+}
+
+func createUrlRequest(url: URL, headers: [String: String]?) -> URLRequest {
+  var request = URLRequest(url: url)
+
+  if let headers {
+    for (key, value) in headers {
+      request.setValue(value, forHTTPHeaderField: key)
+    }
+  }
+  return request
+}
+
+func createUploadTask(session: URLSession, targetUrl: URL, sourceUrl: URL, options: UploadOptions) -> URLSessionUploadTask {
+  var request = createUrlRequest(url: targetUrl, headers: options.headers)
+
+  switch options.uploadType {
+  case .binaryContent:
+    return session.uploadTask(with: request, fromFile: sourceUrl)
+  case .multipart:
+    let boundaryString = UUID().uuidString
+    let data = try? createMultipartBody(boundary: boundaryString, sourceUrl: sourceUrl, options: options)
+
+    request.setValue("multipart/form-data; boundary=\(boundaryString)", forHTTPHeaderField: "Content-Type")
+    request.httpBody = data
+
+    return session.uploadTask(withStreamedRequest: request)
+  }
+}
+
+func createMultipartBody(boundary: String, sourceUrl: URL, options: UploadOptions) throws -> Data {
+  let fileName = options.fieldName ?? sourceUrl.lastPathComponent
+  let fileContents = try String(contentsOf: sourceUrl)
+  let mimeType = options.mimeType ?? findMimeType(forAttachment: sourceUrl)
+
+  let body = """
+\(headersForMultipartParams(options.parameters, boundary: boundary))
+--\(boundary)
+Content-Disposition: form-data; name="\(fileName)"; filename="\(sourceUrl.lastPathComponent)"
+Content-Type: \(mimeType)
+
+\(fileContents)
+--\(boundary)--
+"""
+
+  guard let bodyData = body.data(using: .utf8) else {
+    throw HeaderEncodingFailedException(sourceUrl.absoluteString)
+  }
+  return bodyData
+}
+
+func headersForMultipartParams(_ params: [String: String]?, boundary: String) -> String {
+  guard let params else {
+    return ""
+  }
+  return params.map { (key: String, value: String) in
+"""
+--\(boundary)
+Content-Disposition: form-data; name="\(key)"
+
+\(value)
+"""
+  }
+  .joined()
+}

package/ios/Tests/EXFileSystemSpec.swift

@@ -0,0 +1,55 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+@testable import ExpoFileSystem
+
+class EXFileSystemSpec: ExpoSpec {
+  override func spec() {
+    let fileSystem = EXFileSystem()
+
+    describe("percentEncodedURLFromURIString") {
+      it("should handle encoded URIs") {
+        let encodedUriInput = "file:///var/mobile/@username/branch"
+        let encodedUriExpectedOutput = "file:///var/mobile/@username/branch"
+        let encodedUri = fileSystem.percentEncodedURL(fromURIString: encodedUriInput)
+
+        expect(encodedUri?.absoluteString) == encodedUriExpectedOutput
+        expect(encodedUri?.scheme) == "file"
+      }
+
+      it("should handle UTF-8 characters") {
+        let utf8UriInput = "file:///var/mobile/中文"
+        let utf8UriExpectedOutput = "file:///var/mobile/%E4%B8%AD%E6%96%87"
+        let utf8Uri = fileSystem.percentEncodedURL(fromURIString:utf8UriInput)
+
+        expect(utf8Uri?.absoluteString) == utf8UriExpectedOutput
+        expect(utf8Uri?.scheme) == "file"
+      }
+
+      it("should handle URI with percent, numbers and UTF-8 characters") {
+        let input = "file:///document/directory/%40%2F中文"
+        let expectedOutput = "file:///document/directory/%40%2F%E4%B8%AD%E6%96%87"
+        let uri = fileSystem.percentEncodedURL(fromURIString:input)
+
+        expect(uri?.absoluteString) == expectedOutput
+      }
+
+      it("should not decode percentages in URI") {
+        let input = "file:///document/hello%2Fworld.txt"
+        let unexpectedOutput = "file:///document/hello/world.txt"
+        let uri = fileSystem.percentEncodedURL(fromURIString:input)
+
+        // Should not create a directory named "hello"
+        expect(uri?.absoluteString) != unexpectedOutput
+      }
+
+      it("should handle assets-library URIs") {
+        let assetsLibraryUriInput = "assets-library://asset/asset.JPG?id=3C1D9C54-9521-488F-BB27-AA1EA0F8AF04/L0/001&ext=JPG"
+        let assetsLibraryUri = fileSystem.percentEncodedURL(fromURIString:assetsLibraryUriInput)
+
+        expect(assetsLibraryUri?.absoluteString) == assetsLibraryUriInput
+        expect(assetsLibraryUri?.scheme) == "assets-library"
+      }
+    }
+  }
+}

package/jest.config.js

@@ -0,0 +1,3 @@
+const skipPackageTestsConfig = require('expo-module-scripts/skip-package-tests.jest.config');
+
+module.exports = skipPackageTestsConfig;