react-native-cloud-storage 1.5.0 → 1.5.1

package/src/google-drive/index.ts

@@ -1,4 +1,4 @@
-import type NativeproviderService from '../types/native';
+import type NativeRNCloudStorage from '../types/native';
 import {
   CloudStorageErrorCode,
   type NativeRNCloudCloudStorageFileStat,
@@ -6,30 +6,28 @@ import {
 } from '../types/native';
 import CloudStorageError from '../utils/CloudStorageError';
 import { MimeTypes, type GoogleDriveFile, type GoogleDriveFileSpace } from './types';
+import { DeviceEventEmitter } from 'react-native';
 import GoogleDriveApiClient, { GoogleDriveHttpError } from './client';
-import { type CloudStorageProviderOptions, type DeepRequired } from '../types/main';
 
 /**
  * A proxy class that wraps the Google Drive API client implementation to match the native iOS interface.
  */
-export default class GoogleDrive implements NativeproviderService {
-  private drive: GoogleDriveApiClient;
-  private options: DeepRequired<CloudStorageProviderOptions['googledrive']>;
-
-  constructor(options: DeepRequired<CloudStorageProviderOptions['googledrive']>) {
-    this.options = options;
-    this.drive = new GoogleDriveApiClient(options);
+export default class GoogleDrive implements NativeRNCloudStorage {
+  private static drive: GoogleDriveApiClient = new GoogleDriveApiClient();
+  public static throwOnFilesWithSameName = false;
+  public filesWithSameNameSubscribers: (({ path, fileIds }: { path: string; fileIds: string[] }) => void)[];
 
+  constructor() {
+    this.filesWithSameNameSubscribers = [];
     return new Proxy(this, {
       // before calling any function, check if the access token is set
       get(target: GoogleDrive, prop: keyof GoogleDrive) {
-        const allowedFunctions = ['isCloudAvailable'];
+        const allowedFunctions = ['isCloudAvailable', 'subscribeToFilesWithSameName'];
         if (typeof target[prop] === 'function' && !allowedFunctions.includes(prop.toString())) {
-          const { accessToken } = options;
-          if (!accessToken?.length) {
+          if (!GoogleDrive.drive.accessToken.length) {
             throw new CloudStorageError(
               `Google Drive access token is not set, cannot call function ${prop.toString()}`,
-              CloudStorageErrorCode.ACCESS_TOKEN_MISSING
+              CloudStorageErrorCode.GOOGLE_DRIVE_ACCESS_TOKEN_MISSING
             );
           }
         }
@@ -39,10 +37,37 @@ export default class GoogleDrive implements NativeproviderService {
     });
   }
 
-  public isCloudAvailable: () => Promise<boolean> = async () => {
-    const { accessToken } = this.options;
-    return !!accessToken?.length;
-  };
+  // when setting accessToken, set it on the GDrive instance
+  public static set accessToken(accessToken: string | null) {
+    GoogleDrive.drive.accessToken = accessToken ?? '';
+
+    // emit an event for the useIsCloudAvailable hook
+    DeviceEventEmitter.emit('RNCloudStorage.cloud.availability-changed', {
+      available: !!accessToken?.length,
+    });
+  }
+
+  public static set timeout(timeout: number) {
+    GoogleDrive.drive.timeout = timeout;
+  }
+
+  public static get accessToken(): string | null {
+    return GoogleDrive.drive.accessToken.length ? GoogleDrive.drive.accessToken : null;
+  }
+
+  public subscribeToFilesWithSameName(subscriber: ({ path, fileIds }: { path: string; fileIds: string[] }) => void): {
+    remove: () => void;
+  } {
+    this.filesWithSameNameSubscribers.push(subscriber);
+
+    return {
+      remove: () => {
+        this.filesWithSameNameSubscribers = this.filesWithSameNameSubscribers.filter((s) => s !== subscriber);
+      },
+    };
+  }
+
+  public isCloudAvailable: () => Promise<boolean> = async () => !!GoogleDrive.drive.accessToken.length;
 
   private getRootDirectory(scope: NativeRNCloudCloudStorageScope): GoogleDriveFileSpace {
     switch (scope) {
@@ -116,7 +141,7 @@ export default class GoogleDrive implements NativeproviderService {
    * @returns A promise that resolves to the ID of the root directory or null if it could not be found.
    */
   private async getRootDirectoryId(scope: NativeRNCloudCloudStorageScope): Promise<string | null> {
-    const files = await this.drive.listFiles(this.getRootDirectory(scope));
+    const files = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
     for (const file of files) {
       if (!files.find((f) => f.id === file.parents![0])) return file.parents![0] ?? null;
     }
@@ -130,8 +155,6 @@ export default class GoogleDrive implements NativeproviderService {
     filename: string,
     parentDirectoryId: string | null
   ) {
-    const { strictFilenames } = this.options;
-
     let possibleFiles: GoogleDriveFile[];
     if (parentDirectoryId) {
       possibleFiles = files.filter((f) => f.name === filename && f.parents![0] === parentDirectoryId);
@@ -141,11 +164,13 @@ export default class GoogleDrive implements NativeproviderService {
 
     if (possibleFiles.length <= 1) return;
 
-    if (strictFilenames) {
+    if (GoogleDrive.throwOnFilesWithSameName) {
       throw new CloudStorageError(
         `Multiple files with the same name found at path ${path}: ${possibleFiles.map((f) => f.id).join(', ')}`,
         CloudStorageErrorCode.MULTIPLE_FILES_SAME_NAME
       );
+    } else {
+      this.filesWithSameNameSubscribers.forEach((s) => s({ path, fileIds: possibleFiles.map((f) => f.id) }));
     }
   }
 
@@ -155,7 +180,7 @@ export default class GoogleDrive implements NativeproviderService {
     throwIf: 'directory' | 'file' | false = false
   ): Promise<string> {
     try {
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
+      const files = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
 
       if (path === '' || path === '/') {
         const rootDirectoryId = await this.getRootDirectoryId(scope);
@@ -215,7 +240,7 @@ export default class GoogleDrive implements NativeproviderService {
     let prevContent = '';
     try {
       fileId = await this.getFileId(path, scope);
-      prevContent = await this.drive.getFileText(fileId);
+      prevContent = await GoogleDrive.drive.getFileText(fileId);
     } catch (e: any) {
       if (e instanceof CloudStorageError && e.code === CloudStorageErrorCode.FILE_NOT_FOUND) {
         /* do nothing, simply create the file */
@@ -225,15 +250,15 @@ export default class GoogleDrive implements NativeproviderService {
     }
 
     if (fileId) {
-      await this.drive.updateFile(fileId, {
+      await GoogleDrive.drive.updateFile(fileId, {
         body: prevContent + data,
         mimeType: MimeTypes.TEXT,
       });
     } else {
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
+      const files = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
       const { directories, filename } = this.resolvePathToDirectories(path);
       const parentDirectoryId = this.findParentDirectoryId(files, directories);
-      await this.drive.createFile(
+      await GoogleDrive.drive.createFile(
         {
           name: filename,
           parents: parentDirectoryId
@@ -281,15 +306,15 @@ export default class GoogleDrive implements NativeproviderService {
     }
 
     if (fileId) {
-      await this.drive.updateFile(fileId, {
+      await GoogleDrive.drive.updateFile(fileId, {
         body: data,
         mimeType: MimeTypes.TEXT,
       });
     } else {
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
+      const files = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
       const { directories, filename } = this.resolvePathToDirectories(path);
       const parentDirectoryId = this.findParentDirectoryId(files, directories);
-      await this.drive.createFile(
+      await GoogleDrive.drive.createFile(
         {
           name: filename,
           parents: parentDirectoryId
@@ -307,7 +332,7 @@ export default class GoogleDrive implements NativeproviderService {
   }
 
   async listFiles(path: string, scope: NativeRNCloudCloudStorageScope): Promise<string[]> {
-    const allFiles = await this.drive.listFiles(this.getRootDirectory(scope));
+    const allFiles = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
     if (path !== '') {
       const fileId = await this.getFileId(path, scope);
       const files = allFiles.filter((f) => (f.parents ?? [])[0] === fileId);
@@ -333,11 +358,11 @@ export default class GoogleDrive implements NativeproviderService {
       }
     }
 
-    const files = await this.drive.listFiles(this.getRootDirectory(scope));
+    const files = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
     const { directories, filename } = this.resolvePathToDirectories(path);
     const parentDirectoryId = this.findParentDirectoryId(files, directories);
 
-    await this.drive.createDirectory({
+    await GoogleDrive.drive.createDirectory({
       name: filename,
       parents: parentDirectoryId
         ? [parentDirectoryId]
@@ -349,19 +374,19 @@ export default class GoogleDrive implements NativeproviderService {
 
   async readFile(path: string, scope: NativeRNCloudCloudStorageScope): Promise<string> {
     const fileId = await this.getFileId(path, scope);
-    const content = await this.drive.getFileText(fileId);
+    const content = await GoogleDrive.drive.getFileText(fileId);
     return content;
   }
 
   async downloadFile(_path: string, _scope: NativeRNCloudCloudStorageScope): Promise<void> {
-    // Downloading files from Google Drive is not necessary / possible, as they need to be downloaded on every read operation via the API anyway
+    // Not doing anything here, just a placeholder to conform to the interface so it doesn't fail on Android
     return;
   }
 
   async deleteFile(path: string, scope: NativeRNCloudCloudStorageScope): Promise<void> {
     // if trying to pass a directory, throw an error
     const fileId = await this.getFileId(path, scope, 'directory');
-    await this.drive.deleteFile(fileId);
+    await GoogleDrive.drive.deleteFile(fileId);
   }
 
   async deleteDirectory(path: string, recursive: boolean, scope: NativeRNCloudCloudStorageScope): Promise<void> {
@@ -370,7 +395,7 @@ export default class GoogleDrive implements NativeproviderService {
 
     if (!recursive) {
       // check if the directory is empty
-      const files = await this.drive.listFiles(this.getRootDirectory(scope));
+      const files = await GoogleDrive.drive.listFiles(this.getRootDirectory(scope));
       const filesInDirectory = files.filter((f) => (f.parents ?? [])[0] === fileId);
       if (filesInDirectory.length > 0) {
         throw new CloudStorageError(
@@ -381,12 +406,12 @@ export default class GoogleDrive implements NativeproviderService {
       }
     }
 
-    await this.drive.deleteFile(fileId);
+    await GoogleDrive.drive.deleteFile(fileId);
   }
 
   async statFile(path: string, scope: NativeRNCloudCloudStorageScope): Promise<NativeRNCloudCloudStorageFileStat> {
     const fileId = await this.getFileId(path, scope, false);
-    const file = await this.drive.getFile(fileId!);
+    const file = await GoogleDrive.drive.getFile(fileId!);
 
     return {
       size: file.size ?? 0,

package/src/hooks/useCloudFile.ts

@@ -5,22 +5,20 @@ import { useCallback, useEffect, useState } from 'react';
 /**
  * A utility hook for reading and writing to a single file in the cloud.
  * @param path The path to the file.
- * @param scope The directory scope the path is in. Defaults to the default scope set for the current provider.
- * @param cloudStorageInstance An optional instance of RNCloudStorage to use instead of the default instance.
+ * @param scope The directory scope the path is in. If not provided, defaults to the default scope set in the library.
  * @returns An object containing the file's contents and functions for downloading, reading, writing, and removing the file.
  */
-export const useCloudFile = (path: string, scope?: CloudStorageScope, cloudStorageInstance?: RNCloudStorage) => {
+export const useCloudFile = (path: string, scope?: CloudStorageScope) => {
   const [content, setContent] = useState<string | null>(null);
-  const instance = cloudStorageInstance ?? RNCloudStorage;
 
   const read = useCallback(async () => {
-    const exists = await instance.exists(path, scope);
+    const exists = await RNCloudStorage.exists(path, scope);
     if (!exists) {
       setContent(null);
       return;
     }
-    instance.readFile(path, scope).then(setContent);
-  }, [path, scope, instance]);
+    RNCloudStorage.readFile(path, scope).then(setContent);
+  }, [path, scope]);
 
   useEffect(() => {
     read();
@@ -28,26 +26,31 @@ export const useCloudFile = (path: string, scope?: CloudStorageScope, cloudStora
 
   const write = useCallback(
     async (newContent: string) => {
-      await instance.writeFile(path, newContent, scope);
+      await RNCloudStorage.writeFile(path, newContent, scope);
       read();
     },
-    [path, scope, read, instance]
+    [path, scope, read]
   );
 
   const remove = useCallback(async () => {
-    await instance.unlink(path, scope);
+    await RNCloudStorage.unlink(path, scope);
     setContent(null);
-  }, [path, scope, instance]);
+  }, [path, scope]);
 
   const download = useCallback(async () => {
-    await instance.downloadFile(path, scope);
-  }, [path, scope, instance]);
+    await RNCloudStorage.downloadFile(path, scope);
+  }, [path, scope]);
 
   return {
     content,
     read,
     write,
     remove,
+    /**
+     * @deprecated Use `write` instead.
+     * @alias write
+     */
+    update: write,
     /**
      * Downloads the file from iCloud to the device. Needed if the file hasn't been synced yet. Has no effect on
      * Google Drive.

package/src/hooks/useIsCloudAvailable.ts

@@ -1,30 +1,43 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useEffect, useState } from 'react';
+import { NativeEventEmitter, NativeModules, Platform, DeviceEventEmitter } from 'react-native';
 import RNCloudStorage from '../RNCloudStorage';
 
 /**
  * A hook that tests whether or not the cloud storage is available.
- * @param cloudStorageInstance - An optional instance of RNCloudStorage to use instead of the default instance.
+ * @param _iCloudTimeout DEPRECATED: This parameter is deprecated and has no effect. It will be removed in a future version.
  * @returns A boolean indicating whether or not the cloud storage is available.
  */
-export const useIsCloudAvailable = (cloudStorageInstance?: RNCloudStorage) => {
+export const useIsCloudAvailable = (_iCloudTimeout?: number) => {
   const [isAvailable, setIsAvailable] = useState(false);
-  const instance = cloudStorageInstance ?? RNCloudStorage.getDefaultInstance();
-
-  const handleAvailabilityChange = useCallback((available: boolean) => {
-    setIsAvailable(available);
-  }, []);
 
   useEffect(() => {
     // Set the initial availability state
-    instance.isCloudAvailable().then(setIsAvailable);
+    RNCloudStorage.isCloudAvailable().then(setIsAvailable);
 
     // Listen for changes to the cloud availability using the native event emitter
-    instance.subscribeToCloudAvailability(handleAvailabilityChange);
+    let eventEmitter: NativeEventEmitter | typeof DeviceEventEmitter;
+    if (Platform.OS === 'ios') {
+      eventEmitter = new NativeEventEmitter(NativeModules.CloudStorageEventEmitter);
+    } else {
+      eventEmitter = DeviceEventEmitter;
+    }
+
+    eventEmitter.addListener('RNCloudStorage.cloud.availability-changed', (event: { available: boolean }) => {
+      setIsAvailable(event.available);
+    });
 
     return () => {
-      instance.unsubscribeFromCloudAvailability(handleAvailabilityChange);
+      eventEmitter.removeAllListeners('RNCloudStorage.cloud.availability-changed');
     };
-  }, [instance, handleAvailabilityChange]);
+  }, []);
+
+  useEffect(() => {
+    if (_iCloudTimeout !== undefined) {
+      console.warn(
+        'The iCloudTimeout parameter for useIsCloudFile is deprecated and has no effect. It will be removed in a future version. Please remove it from your code.'
+      );
+    }
+  }, [_iCloudTimeout]);
 
   return isAvailable;
 };

package/src/index.ts

@@ -6,3 +6,8 @@ export * from './hooks/useIsCloudAvailable';
 import CloudStorageError from './utils/CloudStorageError';
 
 export { RNCloudStorage as CloudStorage, CloudStorageError, CloudStorageErrorCode };
+
+/**
+ * @deprecated Use the named export `CloudStorage` instead.
+ */
+export default RNCloudStorage;

package/src/types/main.ts

@@ -1,8 +1,3 @@
-/* Custom utility type to make properties required, but still allow null if defined */
-export type DeepRequired<T> = {
-  [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
-};
-
 export enum CloudStorageScope {
   Documents = 'documents',
   AppData = 'app_data',
@@ -17,36 +12,3 @@ export interface CloudStorageFileStat {
   isDirectory: () => boolean;
   isFile: () => boolean;
 }
-
-export enum CloudStorageProvider {
-  ICloud = 'icloud',
-  GoogleDrive = 'googledrive',
-}
-
-export interface CloudStorageProviderOptions {
-  [CloudStorageProvider.ICloud]: {
-    /**
-     * The directory scope to use for iCloud operations. Defaults to 'app_data'.
-     */
-    scope?: CloudStorageScope;
-  };
-
-  [CloudStorageProvider.GoogleDrive]: {
-    /**
-     * The directory scope to use for Google Drive operations. Defaults to 'app_data'.
-     */
-    scope?: CloudStorageScope;
-    /**
-     * The access token to use for Google Drive operations.
-     */
-    accessToken?: string | null;
-    /**
-     * Whether or not to throw an error if multiple files with the same filename are found. Defaults to false.
-     */
-    strictFilenames?: boolean;
-    /**
-     * The timeout in milliseconds after which to cancel an API request. Defaults to 3000.
-     */
-    timeout?: number;
-  };
-}

package/src/types/native.ts

@@ -9,7 +9,6 @@ export interface NativeRNCloudCloudStorageFileStat {
 }
 
 export enum CloudStorageErrorCode {
-  INVALID_SCOPE = 'ERR_INVALID_SCOPE',
   FILE_NOT_FOUND = 'ERR_FILE_NOT_FOUND',
   PATH_IS_FILE = 'ERR_PATH_IS_FILE',
   PATH_IS_DIRECTORY = 'ERR_PATH_IS_DIRECTORY',
@@ -24,7 +23,7 @@ export enum CloudStorageErrorCode {
   STAT_ERROR = 'ERR_STAT_ERROR',
   UNKNOWN = 'ERR_UNKNOWN',
   FILE_NOT_DOWNLOADABLE = 'ERR_FILE_NOT_DOWNLOADABLE',
-  ACCESS_TOKEN_MISSING = 'ERR_ACCESS_TOKEN_MISSING',
+  GOOGLE_DRIVE_ACCESS_TOKEN_MISSING = 'ERR_GOOGLE_DRIVE_ACCESS_TOKEN_MISSING',
 }
 
 export default interface NativeRNCloudStorage {

package/src/utils/helpers.ts

@@ -1,10 +1,17 @@
-import { CloudStorageProvider } from '../types/main';
-import { Platform } from 'react-native';
-
-export const isProviderSupported = (provider: CloudStorageProvider): boolean => {
-  if (Platform.OS !== 'ios' && provider === CloudStorageProvider.ICloud) {
-    return false;
+/**
+ * Checks if the path starts with a leading slash and adds one if it doesn't to maintain backwards compatibility.
+ * Will log a warning to the console if it had to add a leading slash. Will throw an error in the future.
+ *
+ * @param path The path to check.
+ * @returns The path with a leading slash, if it didn't have one already.
+ * @private
+ */
+export const verifyLeadingSlash = (path: string) => {
+  if (!path.startsWith('/')) {
+    console.warn(
+      `[react-native-cloud-storage] Path "${path}" did not start with a leading slash. This is deprecated and will be an error in the future.`
+    );
+    return `/${path}`;
   }
-
-  return true;
+  return path;
 };

package/ios/Utils/CloudKitUtils.swift

@@ -1,112 +0,0 @@
-//
-//  CloudKitUtils.swift
-//  CloudStorage
-//
-//  Created by Maximilian Krause on 27.09.24.
-//  Copyright © 2024 Kuatsu App Agency. All rights reserved.
-//
-
-import Foundation
-
-enum CloudKitUtils {
-  private static let fileManager = FileManager.default
-
-  /**
-     Checks if the CloudKit service is available.
-
-     - Returns: True if the CloudKit service is available, false otherwise.
-   */
-  static func isCloudKitAvailable() -> Bool {
-    fileManager.ubiquityIdentityToken != nil
-  }
-
-  /**
-     Downloads a file from iCloud.
-
-     - Parameter fileUrl: The URL of the file to download.
-     - Throws: An NSError if the file is not downloadable or the download failed.
-   */
-  static func downloadFile(fileUrl: URL) throws {
-    let isDownloadable = fileManager.isUbiquitousItem(at: fileUrl)
-
-    if !isDownloadable {
-      throw CloudStorageError.fileNotDownloadable(path: fileUrl.path)
-    }
-
-    do {
-      // trigger download of file
-      try fileManager.startDownloadingUbiquitousItem(at: fileUrl)
-    } catch {
-      throw CloudStorageError.fileNotDownloadable(path: fileUrl.path)
-    }
-  }
-
-  /**
-     Returns the iCloud directory URL for the given scope.
-
-     - Parameter scope: The scope of the directory.
-     - Returns: The URL of the iCloud directory, or nil if no directory is found.
-   */
-  private static func getScopeDirectory(scope: DirectoryScope) -> URL? {
-    switch scope {
-    case .appData:
-      appDataDirectory
-    case .documents:
-      documentsDirectory
-    }
-  }
-
-  /**
-     Parses a given path and directory scope to a full file URL.
-
-     - Parameter path: The path of the file.
-     - Parameter scope: The scope of the directory.
-     - Parameter shouldExist: Whether the file should exist. If true, throws an error if the file does not exist. If false, throws an error if the file exists. If nil, does not check if the file exists.
-     - Returns: The full URL of the file.
-     - Throws: An NSError if the scope directory couldn't be found or the file should exist but doesn't or vice versa.
-   */
-  static func getFileURL(path: String, scope: DirectoryScope, _ shouldExist: Bool? = nil) throws -> URL {
-    guard let directory = getScopeDirectory(scope: scope) else {
-      throw CloudStorageError.directoryNotFound(path: path)
-    }
-
-    // append path to scope directory
-    let fileUrl = directory.appendingPathComponent(FileUtils.sanitizePath(path: path))
-
-    if shouldExist != nil {
-      let fileExists = try FileUtils.checkFileExists(fileUrl: fileUrl)
-      if shouldExist! && !fileExists {
-        throw CloudStorageError.fileNotFound(path: path)
-      } else if !shouldExist! && fileExists {
-        throw CloudStorageError.fileAlreadyExists(path: path)
-      }
-    }
-
-    return fileUrl
-  }
-
-  /**
-     Parses a given path and unchecked directory scope to a full file URL.
-
-     - Parameter path: The path of the file.
-     - Parameter scope: The scope of the directory. Will be checked for validity.
-     - Parameter shouldExist: Whether the file should exist. If true, throws an error if the file does not exist. If false, throws an error if the file exists. If nil, does not check if the file exists.
-     - Returns: The full URL of the file.
-     - Throws: An NSError if the scope directory couldn't be found or the file should exist but doesn't or vice versa.
-   */
-  static func getFileURL(path: String, scope: String, _ shouldExist: Bool? = nil) throws -> URL {
-    guard let directoryScope = DirectoryScope(rawValue: scope) else {
-      throw CloudStorageError.invalidScope(scope: scope)
-    }
-
-    return try getFileURL(path: path, scope: directoryScope, shouldExist)
-  }
-
-  static var appDataDirectory: URL? {
-    fileManager.url(forUbiquityContainerIdentifier: nil)
-  }
-
-  static var documentsDirectory: URL? {
-    fileManager.urls(for: .documentDirectory, in: .userDomainMask).first
-  }
-}

package/ios/Utils/CloudStorageError.swift

@@ -1,78 +0,0 @@
-//
-//  CloudStorageError.swift
-//  CloudStorage
-//
-//  Created by Maximilian Krause on 27.09.24.
-//  Copyright © 2024 Kuatsu App Agency. All rights reserved.
-//
-
-import Foundation
-
-enum CloudStorageError: Error {
-  case invalidScope(scope: String)
-  case fileNotFound(path: String)
-  case pathIsDirectory(path: String)
-  case pathIsFile(path: String)
-  case directoryNotFound(path: String)
-  case directoryNotEmpty(path: String)
-  case fileAlreadyExists(path: String)
-  case authenticationFailed
-  case writeError(path: String)
-  case readError(path: String)
-  case deleteError(path: String)
-  case statError(path: String)
-  case unknown(message: String = "An unknown error occurred")
-  case fileNotDownloadable(path: String)
-
-  var code: String {
-    switch self {
-    case .invalidScope: "ERR_INVALID_SCOPE"
-    case .fileNotFound: "ERR_FILE_NOT_FOUND"
-    case .pathIsDirectory: "ERR_PATH_IS_DIRECTORY"
-    case .pathIsFile: "ERR_PATH_IS_FILE"
-    case .directoryNotFound: "ERR_DIRECTORY_NOT_FOUND"
-    case .directoryNotEmpty: "ERR_DIRECTORY_NOT_EMPTY"
-    case .fileAlreadyExists: "ERR_FILE_EXISTS"
-    case .authenticationFailed: "ERR_AUTHENTICATION_FAILED"
-    case .writeError: "ERR_WRITE_ERROR"
-    case .readError: "ERR_READ_ERROR"
-    case .deleteError: "ERR_DELETE_ERROR"
-    case .statError: "ERR_STAT_ERROR"
-    case .unknown: "ERR_UNKNOWN"
-    case .fileNotDownloadable: "ERR_FILE_NOT_DOWNLOADABLE"
-    }
-  }
-
-  var message: String {
-    switch self {
-    case let .invalidScope(scope):
-      "Invalid scope \(scope) provided"
-    case let .fileNotFound(path):
-      "File not found at path \(path)"
-    case let .pathIsDirectory(path):
-      "Path is a directory at path \(path)"
-    case let .pathIsFile(path):
-      "Path is a file at path \(path)"
-    case let .directoryNotFound(path):
-      "Directory not found at path \(path)"
-    case let .directoryNotEmpty(path):
-      "Directory not empty at path \(path)"
-    case let .fileAlreadyExists(path):
-      "File already exists at path \(path)"
-    case .authenticationFailed:
-      "Authentication failed"
-    case let .writeError(path):
-      "Write error for path \(path)"
-    case let .readError(path):
-      "Read error for path \(path)"
-    case let .deleteError(path):
-      "Delete error for path \(path)"
-    case let .statError(path):
-      "Stat error for path \(path)"
-    case let .unknown(message):
-      message
-    case let .fileNotDownloadable(path):
-      "File not downloadable at path \(path)"
-    }
-  }
-}