react-native-cloud-storage 2.2.1 → 2.3.0

package/ios/{CloudStorage.swift → CloudStorageCloudKit.swift}

@@ -1,7 +1,7 @@
 import Foundation
 
-@objc(CloudStorage)
-class CloudStorage: NSObject {
+@objc(CloudStorageCloudKit)
+class CloudStorageCloudKit: NSObject {
   @objc(fileExists:withScope:withResolver:withRejecter:)
   func fileExists(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     withPromise(resolve: resolve, reject: reject) {
@@ -62,11 +62,11 @@ class CloudStorage: NSObject {
     }
   }
 
-  @objc(downloadFile:withScope:withResolver:withRejecter:)
-  func downloadFile(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+  @objc(triggerSync:withScope:withResolver:withRejecter:)
+  func triggerSync(path: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     withPromise(resolve: resolve, reject: reject) {
       let fileUrl = try CloudKitUtils.getFileURL(path: path, scope: scope)
-      return try CloudKitUtils.downloadFile(fileUrl: fileUrl)
+      return try CloudKitUtils.triggerSync(fileUrl: fileUrl)
     }
   }
 
@@ -94,6 +94,61 @@ class CloudStorage: NSObject {
     }
   }
 
+  @objc(downloadFile:withLocalPath:withScope:withResolver:withRejecter:)
+  func downloadFile(remotePath: String, localPath: String, scope: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let sourceUrl = try CloudKitUtils.getFileURL(path: remotePath, scope: scope, true)
+
+      let sourceStat = try FileUtils.statFile(fileUrl: sourceUrl)
+      if sourceStat.isDirectory {
+        throw CloudStorageError.pathIsDirectory(path: remotePath)
+      }
+
+      let destinationUrl = URL(fileURLWithPath: localPath)
+      let destinationDirectoryUrl = destinationUrl.deletingLastPathComponent()
+
+      if try !FileUtils.checkFileExists(fileUrl: destinationDirectoryUrl) {
+        throw CloudStorageError.directoryNotFound(path: destinationDirectoryUrl.path)
+      }
+
+      let destDirStat = try FileUtils.statFile(fileUrl: destinationDirectoryUrl)
+      if !destDirStat.isDirectory {
+        throw CloudStorageError.pathIsFile(path: destinationDirectoryUrl.path)
+      }
+
+      if try FileUtils.checkFileExists(fileUrl: destinationUrl) {
+        throw CloudStorageError.fileAlreadyExists(path: localPath)
+      }
+
+      return try FileUtils.copyFile(from: sourceUrl, to: destinationUrl)
+    }
+  }
+
+  @objc(uploadFile:withLocalPath:withMimeType:withScope:withOverwrite:withResolver:withRejecter:)
+  func uploadFile(remotePath: String, localPath: String, mimeType _: String, scope: String, overwrite: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let destinationUrl = try CloudKitUtils.getFileURL(path: remotePath, scope: scope)
+      let sourceUrl = URL(fileURLWithPath: localPath)
+
+      if try !FileUtils.checkFileExists(fileUrl: sourceUrl) {
+        throw CloudStorageError.fileNotFound(path: localPath)
+      }
+
+      let destinationDirectoryUrl = destinationUrl.deletingLastPathComponent()
+      try FileUtils.createDirectory(directoryUrl: destinationDirectoryUrl)
+
+      if try FileUtils.checkFileExists(fileUrl: destinationUrl) {
+        if overwrite {
+          try FileUtils.deleteFileOrDirectory(fileUrl: destinationUrl)
+        } else {
+          throw CloudStorageError.fileAlreadyExists(path: remotePath)
+        }
+      }
+
+      return try FileUtils.copyFile(from: sourceUrl, to: destinationUrl)
+    }
+  }
+
   @objc(isCloudAvailable:withRejecter:)
   func isCloudAvailable(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     withPromise(resolve: resolve, reject: reject) {

package/ios/CloudStorageLocalFileSystem.m

@@ -0,0 +1,15 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(CloudStorageLocalFileSystem, NSObject)
+
+RCT_EXTERN_METHOD(readFile:(NSString *)path withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(createFile:(NSString *)path withData:(NSString *)data withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(downloadFile:(NSString *)remoteUri withLocalPath:(NSString *)localPath withOptions:(NSDictionary *)options withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(uploadFile:(NSString *)localPath withRemoteUri:(NSString *)remoteUri withOptions:(NSDictionary *)options withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/CloudStorageLocalFileSystem.swift

@@ -0,0 +1,215 @@
+import Foundation
+import MobileCoreServices
+
+// MARK: - CloudStorageLocalFileSystem
+
+@objc(CloudStorageLocalFileSystem)
+class CloudStorageLocalFileSystem: NSObject {
+  @objc
+  func constantsToExport() -> [AnyHashable: Any]! {
+    [
+      "temporaryDirectory": FileUtils.temporaryDirectory.path,
+    ]
+  }
+
+  @objc(createFile:withData:withResolver:withRejecter:)
+  func createFile(path: String, data: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = URL(fileURLWithPath: path)
+      let directoryUrl = fileUrl.deletingLastPathComponent()
+
+      var isDirectory: ObjCBool = false
+      if !FileManager.default.fileExists(atPath: directoryUrl.path, isDirectory: &isDirectory) {
+        throw CloudStorageError.directoryNotFound(path: directoryUrl.path)
+      }
+
+      if !isDirectory.boolValue {
+        throw CloudStorageError.pathIsFile(path: directoryUrl.path)
+      }
+
+      try FileUtils.writeFile(fileUrl: fileUrl, content: data)
+      return fileUrl.path
+    }
+  }
+
+  @objc(readFile:withResolver:withRejecter:)
+  func readFile(path: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    withPromise(resolve: resolve, reject: reject) {
+      let fileUrl = URL(fileURLWithPath: path)
+      return try FileUtils.readFile(fileUrl: fileUrl)
+    }
+  }
+
+  @objc(downloadFile:withLocalPath:withOptions:withResolver:withRejecter:)
+  func downloadFile(remoteUri: String, localPath: String, options: [String: Any]?, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    guard let remoteUrl = URL(string: remoteUri) else {
+      let error = CloudStorageError.invalidUrl(url: remoteUri)
+      reject(error.code, error.message, nil)
+      return
+    }
+
+    let sanitizedPath = sanitizePath(localPath)
+    let localUrl = URL(fileURLWithPath: sanitizedPath)
+
+    let configuration = URLSessionConfiguration.default
+    if let headers = options?["headers"] as? [String: String] {
+      configuration.httpAdditionalHeaders = headers
+    }
+    let session = URLSession(configuration: configuration)
+
+    let downloadTask = session.downloadTask(with: remoteUrl) { tempLocalUrl, _, error in
+      if let error {
+        let nsError = error as NSError
+        let cloudError = CloudStorageError.networkError(message: "Download error for path \(remoteUri): \(nsError.localizedDescription)")
+        reject(cloudError.code, cloudError.message, nsError)
+        return
+      }
+
+      guard let tempLocalUrl else {
+        let cloudError = CloudStorageError.unknown(message: "Download failed: temporary file location is missing.")
+        reject(cloudError.code, cloudError.message, nil)
+        return
+      }
+
+      do {
+        let directory = localUrl.deletingLastPathComponent()
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true, attributes: nil)
+
+        if FileManager.default.fileExists(atPath: localUrl.path) {
+          try FileManager.default.removeItem(at: localUrl)
+        }
+
+        try FileManager.default.moveItem(at: tempLocalUrl, to: localUrl)
+        resolve(nil)
+      } catch {
+        let nsError = error as NSError
+        let cloudError = CloudStorageError.writeError(path: localUrl.path)
+        reject(cloudError.code, cloudError.message, nsError)
+      }
+    }
+
+    downloadTask.resume()
+  }
+
+  @objc(uploadFile:withRemoteUri:withOptions:withResolver:withRejecter:)
+  func uploadFile(localPath: String, remoteUri: String, options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    guard let remoteUrl = URL(string: remoteUri) else {
+      let error = CloudStorageError.invalidUrl(url: remoteUri)
+      reject(error.code, error.message, nil)
+      return
+    }
+
+    let sanitizedPath = sanitizePath(localPath)
+    let localUrl = URL(fileURLWithPath: sanitizedPath)
+
+    guard let uploadTypeString = options["uploadType"] as? String,
+          let uploadType = UploadType(rawValue: uploadTypeString) else {
+      let error = CloudStorageError.unknown(message: "uploadType is required and must be either 'multipart' or 'binary'")
+      reject(error.code, error.message, nil)
+      return
+    }
+
+    var request = URLRequest(url: remoteUrl)
+    request.httpMethod = (options["method"] as? String)?.uppercased() ?? "POST"
+
+    if let headers = options["headers"] as? [String: String] {
+      for (key, value) in headers {
+        request.setValue(value, forHTTPHeaderField: key)
+      }
+    }
+
+    do {
+      let fileData = try Data(contentsOf: localUrl)
+
+      switch uploadType {
+      case .binary:
+        request.httpBody = fileData
+        if request.value(forHTTPHeaderField: "Content-Type") == nil {
+          request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
+        }
+      case .multipart:
+        guard let fieldName = options["fieldName"] as? String else {
+          let error = CloudStorageError.unknown(message: "fieldName is required for multipart uploads")
+          reject(error.code, error.message, nil)
+          return
+        }
+
+        let boundary = "Boundary-\(UUID().uuidString)"
+        request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+
+        var body = Data()
+        let lineBreak = "\r\n"
+
+        if let parameters = options["parameters"] as? [String: String] {
+          for (key, value) in parameters {
+            body.append("--\(boundary)\(lineBreak)")
+            body.append("Content-Disposition: form-data; name=\"\(key)\"\(lineBreak)\(lineBreak)")
+            body.append("\(value)\(lineBreak)")
+          }
+        }
+
+        body.append("--\(boundary)\(lineBreak)")
+        body.append("Content-Disposition: form-data; name=\"\(fieldName)\"; filename=\"\(localUrl.lastPathComponent)\"\(lineBreak)")
+        if let mimeType = getMimeType(for: localUrl) {
+          body.append("Content-Type: \(mimeType)\(lineBreak)\(lineBreak)")
+        } else {
+          body.append("Content-Type: application/octet-stream\(lineBreak)\(lineBreak)")
+        }
+        body.append(fileData)
+        body.append(lineBreak)
+        body.append("--\(boundary)--\(lineBreak)")
+
+        request.httpBody = body
+      }
+
+      let task = URLSession.shared.dataTask(with: request) { _, response, error in
+        if let error {
+          let nsError = error as NSError
+          let cloudError = CloudStorageError.networkError(message: "Upload error for path \(sanitizedPath): \(nsError.localizedDescription)")
+          reject(cloudError.code, cloudError.message, nsError)
+          return
+        }
+
+        guard let httpResponse = response as? HTTPURLResponse, (200 ... 299).contains(httpResponse.statusCode) else {
+          let httpResponse = response as? HTTPURLResponse
+          let message = "Upload failed for path \(sanitizedPath) with status code: \(httpResponse?.statusCode ?? -1)"
+          let cloudError = CloudStorageError.networkError(message: message)
+          reject(cloudError.code, cloudError.message, nil)
+          return
+        }
+
+        resolve(nil)
+      }
+      task.resume()
+    } catch {
+      let nsError = error as NSError
+      let cloudError = CloudStorageError.readError(path: sanitizedPath)
+      reject(cloudError.code, cloudError.message, nsError)
+    }
+  }
+
+  private func sanitizePath(_ path: String) -> String {
+    if path.hasPrefix("file://") {
+      return String(path.dropFirst("file://".count))
+    }
+    return path
+  }
+
+  private func getMimeType(for url: URL) -> String? {
+    let pathExtension = url.pathExtension
+    if let uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension as CFString, nil)?.takeRetainedValue() {
+      if let mimetype = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() {
+        return mimetype as String
+      }
+    }
+    return nil
+  }
+}
+
+extension Data {
+  mutating func append(_ string: String) {
+    if let data = string.data(using: .utf8) {
+      append(data)
+    }
+  }
+}

package/ios/Utils/CloudKitUtils.swift

@@ -21,12 +21,12 @@ enum CloudKitUtils {
   }
 
   /**
-     Downloads a file from iCloud.
+     Syncs a file from iCloud to the device.
 
-     - Parameter fileUrl: The URL of the file to download.
-     - Throws: An NSError if the file is not downloadable or the download failed.
+     - Parameter fileUrl: The URL of the file to sync.
+     - Throws: An NSError if the file is not downloadable or the sync failed.
    */
-  static func downloadFile(fileUrl: URL) throws {
+  static func triggerSync(fileUrl: URL) throws {
     let isDownloadable = fileManager.isUbiquitousItem(at: fileUrl)
 
     if !isDownloadable {

package/ios/Utils/CloudStorageError.swift

@@ -23,6 +23,8 @@ enum CloudStorageError: Error {
   case statError(path: String)
   case unknown(message: String = "An unknown error occurred")
   case fileNotDownloadable(path: String)
+  case invalidUrl(url: String)
+  case networkError(message: String)
 
   var code: String {
     switch self {
@@ -40,6 +42,8 @@ enum CloudStorageError: Error {
     case .statError: "ERR_STAT_ERROR"
     case .unknown: "ERR_UNKNOWN"
     case .fileNotDownloadable: "ERR_FILE_NOT_DOWNLOADABLE"
+    case .invalidUrl: "ERR_INVALID_URL"
+    case .networkError: "ERR_NETWORK_ERROR"
     }
   }
 
@@ -73,6 +77,10 @@ enum CloudStorageError: Error {
       message
     case let .fileNotDownloadable(path):
       "File not downloadable at path \(path)"
+    case let .invalidUrl(url):
+      "Invalid URL provided: \(url)"
+    case let .networkError(message):
+      message
     }
   }
 }

package/ios/Utils/FileUtils.swift

@@ -94,6 +94,21 @@ enum FileUtils {
     }
   }
 
+  /**
+    Copies a file from a source to a destination.
+
+    - Parameter sourceUrl: The URL of the file to copy from.
+    - Parameter destinationUrl: The URL to copy the file to.
+    - Throws: An NSError if the file couldn't be copied.
+   */
+  static func copyFile(from sourceUrl: URL, to destinationUrl: URL) throws {
+    do {
+      try fileManager.copyItem(at: sourceUrl, to: destinationUrl)
+    } catch {
+      throw CloudStorageError.writeError(path: destinationUrl.path)
+    }
+  }
+
   /**
      Gets the stats of a file.
 
@@ -129,4 +144,8 @@ enum FileUtils {
   static func sanitizePath(path: String) -> String {
     path.replacingOccurrences(of: "^/+", with: "", options: .regularExpression)
   }
+
+  static var temporaryDirectory: URL {
+    fileManager.temporaryDirectory
+  }
 }

package/ios/Utils/Types.swift

@@ -8,9 +8,15 @@
 
 import Foundation
 
+// MARK: - UploadType
+
+enum UploadType: String {
+  case multipart
+  case binary
+}
+
 // MARK: - DirectoryScope
 
-@frozen
 enum DirectoryScope: String {
   case appData = "app_data"
   case documents

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "react-native-cloud-storage",
-  "version": "2.2.1",
-  "description": "Save to & read from iCloud and Google Drive using React Native",
-  "main": "lib/commonjs/index",
-  "module": "lib/module/index",
-  "types": "lib/typescript/index.d.ts",
+  "version": "2.3.0",
+  "description": "☁️ Save to & read from iCloud and Google Drive using React Native",
+  "main": "dist/commonjs/index",
+  "module": "dist/module/index",
+  "types": "dist/typescript/index.d.ts",
   "react-native": "src/index",
   "source": "src/index",
   "files": [
     "src",
-    "lib",
+    "dist",
     "android",
     "ios",
     "cpp",
     "*.podspec",
     "app.plugin.js",
-    "!lib/typescript/example",
+    "!dist/typescript/example",
     "!ios/build",
     "!android/build",
     "!android/gradle",
@@ -27,54 +27,48 @@
     "!**/__mocks__",
     "!**/.*"
   ],
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "icloud",
+    "google-drive",
+    "file-system"
+  ],
   "scripts": {
+    "clean": "del-cli android/build ios/build dist",
+    "build": "yarn clean && bob build && rm -f dist/commonjs/package.json",
     "test": "jest",
-    "example": "yarn workspace react-native-cloud-storage-example",
-    "docs": "yarn workspace react-native-cloud-storage-docs",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
-    "prepare": "yarn clean && bob build && rm -f lib/commonjs/package.json",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write . && ./scripts/swiftformat.sh",
     "release": "release-it",
-    "check": "yarn lint && scripts/swiftformat.sh"
+    "prepack": "cp ../../README.md ./README.md",
+    "postpack": "rm ./README.md"
   },
-  "keywords": [
-    "react-native",
-    "ios",
-    "android"
-  ],
-  "repository": "https://github.com/Kuatsu/react-native-cloud-storage",
-  "author": "Kuatsu App Agency <hello@kuatsu.de> (https://github.com/Kuatsu)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuatsu/react-native-cloud-storage.git"
+  },
+  "author": "Kuatsu App Agency <hello@kuatsu.de>",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/Kuatsu/react-native-cloud-storage/issues"
+    "url": "https://github.com/kuatsu/react-native-cloud-storage/issues"
   },
-  "homepage": "https://github.com/Kuatsu/react-native-cloud-storage#readme",
+  "homepage": "https://github.com/kuatsu/react-native-cloud-storage#readme",
+  "packageManager": "yarn@3.6.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@commitlint/config-conventional": "^17.0.2",
-    "@evilmartians/lefthook": "^1.5.0",
-    "@expo/config-plugins": "^7.2.5",
-    "@react-native-community/eslint-config": "^3.2.0",
-    "@react-native/eslint-config": "0.74.87",
+    "@expo/config-plugins": "^10.0.2",
     "@release-it/conventional-changelog": "^5.0.0",
-    "@types/jest": "^28.1.2",
-    "@types/react": "^18.2.6",
-    "commitlint": "^17.0.2",
-    "del-cli": "^5.0.0",
-    "eslint": "^8.4.1",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "jest": "^28.1.1",
-    "pod-install": "^0.2.2",
-    "prettier": "^2.0.5",
-    "react": "18.2.0",
-    "react-native": "0.74.5",
+    "@types/react": "~19.0.10",
+    "react": "19.0.0",
+    "react-native": "0.79.3",
     "react-native-builder-bob": "^0.30.2",
     "release-it": "^15.0.0",
-    "typescript": "^5.0.2"
+    "typescript": "~5.8.3"
   },
   "peerDependencies": {
     "expo": ">=48.0.0",
@@ -86,24 +80,10 @@
       "optional": true
     }
   },
-  "workspaces": [
-    "example",
-    "docs"
-  ],
-  "engines": {
-    "node": ">= 18.0.0"
-  },
-  "packageManager": "yarn@3.6.1",
   "jest": {
     "preset": "react-native",
     "modulePathIgnorePatterns": [
-      "<rootDir>/example/node_modules",
-      "<rootDir>/lib/"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
+      "<rootDir>/dist/"
     ]
   },
   "release-it": {
@@ -112,65 +92,26 @@
       "tagName": "v${version}"
     },
     "npm": {
-      "publish": true
+      "publish": true,
+      "versionArgs": [
+        "--workspaces-update=false"
+      ]
     },
     "github": {
       "release": true
     },
     "plugins": {
       "@release-it/conventional-changelog": {
-        "preset": "angular"
+        "preset": {
+          "name": "angular"
+        },
+        "infile": "CHANGELOG.md"
       }
     }
   },
-  "eslintConfig": {
-    "root": true,
-    "extends": [
-      "@react-native-community",
-      "prettier"
-    ],
-    "rules": {
-      "react-native/no-inline-styles": "off",
-      "prettier/prettier": [
-        "error",
-        {
-          "printWidth": 120,
-          "tabWidth": 2,
-          "useTabs": false,
-          "semi": true,
-          "singleQuote": true,
-          "quoteProps": "consistent",
-          "jsxSingleQuote": false,
-          "trailingComma": "es5",
-          "bracketSpacing": true,
-          "bracketSameLine": true,
-          "arrowParens": "always",
-          "endOfLine": "lf"
-        }
-      ]
-    }
-  },
-  "eslintIgnore": [
-    "node_modules/",
-    "lib/"
-  ],
-  "prettier": {
-    "printWidth": 120,
-    "tabWidth": 2,
-    "useTabs": false,
-    "semi": true,
-    "singleQuote": true,
-    "quoteProps": "consistent",
-    "jsxSingleQuote": false,
-    "trailingComma": "es5",
-    "bracketSpacing": true,
-    "bracketSameLine": true,
-    "arrowParens": "always",
-    "endOfLine": "lf"
-  },
   "react-native-builder-bob": {
     "source": "src",
-    "output": "lib",
+    "output": "dist",
     "targets": [
       "commonjs",
       "module",