@react-native-firebase/storage 20.1.0 → 20.2.1

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [20.2.1](https://github.com/invertase/react-native-firebase/compare/v20.2.0...v20.2.1) (2024-07-17)
+
+### Bug Fixes
+
+- **storage:** ensure emulator is used for different storage buckets ([#7892](https://github.com/invertase/react-native-firebase/issues/7892)) ([3fa3f11](https://github.com/invertase/react-native-firebase/commit/3fa3f110b357ef0dbe2cc0fc12e982edc913b588))
+
+## [20.2.0](https://github.com/invertase/react-native-firebase/compare/v20.1.0...v20.2.0) (2024-07-15)
+
+### Features
+
+- **other:** Add Storage support ([#7888](https://github.com/invertase/react-native-firebase/issues/7888)) ([9b8dda7](https://github.com/invertase/react-native-firebase/commit/9b8dda704a01243039624bfcc7614021e6c3a527))
+
 ## [20.1.0](https://github.com/invertase/react-native-firebase/compare/v20.0.0...v20.1.0) (2024-06-04)
 
 **Note:** Version bump only for package @react-native-firebase/storage

package/android/src/main/java/io/invertase/firebase/storage/ReactNativeFirebaseStorageModule.java

@@ -281,12 +281,15 @@ public class ReactNativeFirebaseStorageModule extends ReactNativeFirebaseModule
    * @link https://firebase.google.com/docs/reference/js/firebase.storage.Storage#useEmulator
    */
   @ReactMethod
-  public void useEmulator(String appName, String host, int port, Promise promise) {
+  public void useEmulator(String appName, String host, int port, String bucketUrl, Promise promise) {
     FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
-    FirebaseStorage firebaseStorage = FirebaseStorage.getInstance(firebaseApp);
-    if (emulatorConfigs.get(appName) == null) {
+
+    FirebaseStorage firebaseStorage = FirebaseStorage.getInstance(firebaseApp, bucketUrl);
+    String emulatorKey = appName + ":" + bucketUrl;
+
+    if (emulatorConfigs.get(emulatorKey) == null) {
       firebaseStorage.useEmulator(host, port);
-      emulatorConfigs.put(appName, "true");
+      emulatorConfigs.put(emulatorKey, "true");
     }
     promise.resolve(null);
   }

package/ios/RNFBStorage/RNFBStorageModule.m

@@ -511,12 +511,15 @@ RCT_EXPORT_METHOD(putString
 RCT_EXPORT_METHOD(useEmulator
                   : (FIRApp *)firebaseApp
                   : (nonnull NSString *)host
-                  : (NSInteger)port) {
+                  : (NSInteger)port
+                  : (NSString *)bucketUrl) {
   emulatorHost = host;
   emulatorPort = port;
-  if (!emulatorConfigs[firebaseApp.name]) {
-    [[FIRStorage storageForApp:firebaseApp] useEmulatorWithHost:host port:port];
-    emulatorConfigs[firebaseApp.name] = @YES;
+  NSString *key = [self createEmulatorKey:bucketUrl appName:firebaseApp.name];
+
+  if (!emulatorConfigs[key]) {
+    [[FIRStorage storageForApp:firebaseApp URL:bucketUrl] useEmulatorWithHost:host port:port];
+    emulatorConfigs[key] = @YES;
   }
 }
 
@@ -557,6 +560,10 @@ RCT_EXPORT_METHOD(setTaskStatus
 #pragma mark -
 #pragma mark Firebase Storage Internals
 
+- (NSString *)createEmulatorKey:(NSString *)bucketUrl appName:(NSString *)appName {
+  return [NSString stringWithFormat:@"%@-%@", appName, bucketUrl];
+}
+
 - (void)addUploadTaskObservers:(FIRStorageUploadTask *)uploadTask
                 appDisplayName:(NSString *)appDisplayName
                         taskId:(NSNumber *)taskId
@@ -675,11 +682,11 @@ RCT_EXPORT_METHOD(setTaskStatus
   storage = [FIRStorage storageForApp:firebaseApp URL:bucket];
 
   NSLog(@"Setting emulator - host %@ port %ld", emulatorHost, (long)emulatorPort);
-  if (![emulatorHost isEqual:[NSNull null]] && emulatorHost != nil &&
-      !emulatorConfigs[firebaseApp.name]) {
+  NSString *key = [self createEmulatorKey:bucket appName:firebaseApp.name];
+  if (![emulatorHost isEqual:[NSNull null]] && emulatorHost != nil && !emulatorConfigs[key]) {
     @try {
       [storage useEmulatorWithHost:emulatorHost port:emulatorPort];
-      emulatorConfigs[firebaseApp.name] = @YES;
+      emulatorConfigs[key] = @YES;
     } @catch (NSException *e) {
       NSLog(@"WARNING: Unable to set the Firebase Storage emulator settings. These must be set "
             @"before any usages of Firebase Storage. If you see this log after a hot "

package/lib/index.js

@@ -16,6 +16,7 @@
  */
 
 import { isAndroid, isNumber, isString } from '@react-native-firebase/app/lib/common';
+import { setReactNativeModule } from '@react-native-firebase/app/lib/internal/nativeModule';
 import {
   createModuleNamespace,
   FirebaseModule,
@@ -25,6 +26,7 @@ import StorageReference from './StorageReference';
 import StorageStatics from './StorageStatics';
 import { getGsUrlParts, getHttpUrlParts, handleStorageEvent } from './utils';
 import version from './version';
+import fallBackModule from './web/RNFBStorageModule';
 
 export {
   getStorage,
@@ -201,7 +203,7 @@ class FirebaseStorageModule extends FirebaseModule {
     }
     this.emulatorHost = host;
     this.emulatorPort = port;
-    this.native.useEmulator(_host, port);
+    this.native.useEmulator(_host, port, this._customUrlOrRegion);
     return [_host, port]; // undocumented return, just used to unit test android host remapping
   }
 }
@@ -230,3 +232,5 @@ export default createModuleNamespace({
 // storage().X(...);
 // firebase.storage().X(...);
 export const firebase = getFirebaseRoot();
+
+setReactNativeModule(nativeModuleName, fallBackModule);

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '20.1.0';
+module.exports = '20.2.1';

package/lib/web/RNFBStorageModule.android.js

@@ -0,0 +1,2 @@
+// No-op for android.
+export default {};

package/lib/web/RNFBStorageModule.ios.js

@@ -0,0 +1,2 @@
+// No-op for ios.
+export default {};

package/lib/web/RNFBStorageModule.js

@@ -0,0 +1,462 @@
+import {
+  getApps,
+  connectStorageEmulator,
+  getApp,
+  getStorage,
+  deleteObject,
+  getDownloadURL,
+  getMetadata,
+  list,
+  listAll,
+  updateMetadata,
+  uploadBytesResumable,
+  ref as firebaseStorageRef,
+} from '@react-native-firebase/app/lib/internal/web/firebaseStorage';
+import { guard, getWebError, emitEvent } from '@react-native-firebase/app/lib/internal/web/utils';
+import { Base64 } from '@react-native-firebase/app/lib/common';
+
+function rejectWithCodeAndMessage(code, message) {
+  return Promise.reject(
+    getWebError({
+      code,
+      message,
+    }),
+  );
+}
+
+function metadataToObject(metadata) {
+  const out = {
+    bucket: metadata.bucket,
+    generation: metadata.generation,
+    metageneration: metadata.metageneration,
+    fullPath: metadata.fullPath,
+    name: metadata.name,
+    size: metadata.size,
+    timeCreated: metadata.timeCreated,
+    updated: metadata.updated,
+    md5Hash: metadata.md5Hash,
+  };
+
+  if ('cacheControl' in metadata) {
+    out.cacheControl = metadata.cacheControl;
+  }
+
+  if ('contentLanguage' in metadata) {
+    out.contentLanguage = metadata.contentLanguage;
+  }
+
+  if ('contentDisposition' in metadata) {
+    out.contentDisposition = metadata.contentDisposition;
+  }
+
+  if ('contentEncoding' in metadata) {
+    out.contentEncoding = metadata.contentEncoding;
+  }
+
+  if ('contentType' in metadata) {
+    out.contentType = metadata.contentType;
+  }
+
+  if ('customMetadata' in metadata) {
+    out.customMetadata = metadata.customMetadata;
+    // To match Android/iOS
+    out.metadata = metadata.customMetadata;
+  }
+
+  return out;
+}
+
+function uploadTaskErrorToObject(error, snapshot) {
+  return {
+    ...uploadTaskSnapshotToObject(snapshot),
+    state: 'error',
+    error: getWebError(error),
+  };
+}
+
+function uploadTaskSnapshotToObject(snapshot) {
+  return {
+    totalBytes: snapshot ? snapshot.totalBytes : 0,
+    bytesTransferred: snapshot ? snapshot.bytesTransferred : 0,
+    state: snapshot ? taskStateToString(snapshot.state) : 'unknown',
+    metadata: snapshot ? metadataToObject(snapshot.metadata) : {},
+  };
+}
+
+function taskStateToString(state) {
+  const override = {
+    canceled: 'cancelled',
+  };
+
+  if (state in override) {
+    return override[state];
+  }
+
+  return state;
+}
+
+function makeSettableMetadata(metadata) {
+  return {
+    cacheControl: metadata.cacheControl,
+    contentDisposition: metadata.contentDisposition,
+    contentEncoding: metadata.contentEncoding,
+    contentType: metadata.contentType,
+    contentLanguage: metadata.contentLanguage,
+    customMetadata: metadata.customMetadata,
+  };
+}
+
+function listResultToObject(result) {
+  return {
+    nextPageToken: result.nextPageToken,
+    items: result.items.map(ref => ref.fullPath),
+    prefixes: result.prefixes.map(ref => ref.fullPath),
+  };
+}
+
+const emulatorForApp = {};
+const appInstances = {};
+const storageInstances = {};
+const tasks = {};
+
+function getBucketFromUrl(url) {
+  const pathWithBucketName = url.substring(5);
+  const bucket = url.substring(0, pathWithBucketName.indexOf('/') + 5);
+  return bucket;
+}
+
+function getCachedAppInstance(appName) {
+  return (appInstances[appName] ??= getApp(appName));
+}
+
+// Returns a cached Storage instance.
+function getCachedStorageInstance(appName, url) {
+  let instance;
+  if (!url) {
+    instance = getCachedStorageInstance(
+      appName,
+      getCachedAppInstance(appName).options.storageBucket,
+    );
+  } else {
+    const bucket = getBucketFromUrl(url);
+    instance = storageInstances[`${appName}|${bucket}`] ??= getStorage(
+      getCachedAppInstance(appName),
+      bucket,
+    );
+  }
+  if (emulatorForApp[appName]) {
+    connectStorageEmulator(instance, emulatorForApp[appName].host, emulatorForApp[appName].port);
+  }
+  return instance;
+}
+
+// Returns a Storage Reference.
+function getReferenceFromUrl(appName, url) {
+  const path = url.substring(url.indexOf('/') + 1);
+  const instance = getCachedStorageInstance(appName, path);
+  return firebaseStorageRef(instance, url);
+}
+
+const CONSTANTS = {};
+const defaultAppInstance = getApps()[0];
+
+if (defaultAppInstance) {
+  CONSTANTS.maxDownloadRetryTime = 0;
+  CONSTANTS.maxOperationRetryTime = 0;
+  CONSTANTS.maxUploadRetryTime = 0;
+}
+
+export default {
+  ...CONSTANTS,
+
+  /**
+   * Delete an object at the path.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @return {Promise<void>}
+   */
+  delete(appName, url) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+      await deleteObject(ref);
+    });
+  },
+
+  /**
+   * Get the download URL for an object.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @return {Promise<string>} The download URL.
+   */
+  getDownloadURL(appName, url) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+      const downloadURL = await getDownloadURL(ref);
+      return downloadURL;
+    });
+  },
+
+  /**
+   * Get the metadata for an object.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @return {Promise<Object>} The metadata.
+   */
+  getMetadata(appName, url) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+      const metadata = await getMetadata(ref);
+      return metadataToObject(metadata);
+    });
+  },
+
+  /**
+   * List objects at the path.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @param {Object} listOptions - The list options.
+   * @return {Promise<Object>} The list result.
+   */
+  list(appName, url, listOptions) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+      const listResult = await list(ref, listOptions);
+      return listResultToObject(listResult);
+    });
+  },
+
+  /**
+   * List all objects at the path.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @return {Promise<Object>} The list result.
+   */
+  listAll(appName, url) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+      const listResult = await listAll(ref);
+      return listResultToObject(listResult);
+    });
+  },
+
+  /**
+   * Update the metadata for an object.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @param {Object} metadata - The metadata (SettableMetadata).
+   */
+  updateMetadata(appName, url, metadata) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+      const updated = await updateMetadata(ref, makeSettableMetadata(metadata));
+      return metadataToObject(updated);
+    });
+  },
+
+  setMaxDownloadRetryTime() {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        'The Firebase Storage `setMaxDownloadRetryTime` method is not available in the this environment.',
+      );
+      return;
+    }
+  },
+
+  /**
+   * Set the maximum operation retry time.
+   * @param {string} appName - The app name.
+   * @param {number} milliseconds - The maximum operation retry time.
+   * @return {Promise<void>}
+   */
+  setMaxOperationRetryTime(appName, milliseconds) {
+    return guard(async () => {
+      const storage = getCachedStorageInstance(appName);
+      storage.maxOperationRetryTime = milliseconds;
+    });
+  },
+
+  /**
+   * Set the maximum upload retry time.
+   * @param {string} appName - The app name.
+   * @param {number} milliseconds - The maximum upload retry time.
+   * @return {Promise<void>}
+   */
+  setMaxUploadRetryTime(appName, milliseconds) {
+    return guard(async () => {
+      const storage = getCachedStorageInstance(appName);
+      storage.maxUploadRetryTime = milliseconds;
+    });
+  },
+
+  /**
+   * Use the Firebase Storage emulator.
+   * @param {string} appName - The app name.
+   * @param {string} host - The emulator host.
+   * @param {number} port - The emulator port.
+   * @return {Promise<void>}
+   */
+  useEmulator(appName, host, port) {
+    return guard(async () => {
+      const instance = getCachedStorageInstance(appName);
+      connectStorageEmulator(instance, host, port);
+      emulatorForApp[appName] = { host, port };
+    });
+  },
+
+  writeToFile() {
+    return rejectWithCodeAndMessage(
+      'unsupported',
+      'This operation is not supported in this environment.',
+    );
+  },
+
+  /**
+   * Put a string to the path.
+   * @param {string} appName - The app name.
+   * @param {string} url - The path to the object.
+   * @param {string} string - The string to put.
+   * @param {string} format - The format of the string.
+   * @param {Object} metadata - The metadata (SettableMetadata).
+   * @param {string} taskId - The task ID.
+   * @return {Promise<Object>} The upload snapshot.
+   */
+  putString(appName, url, string, format, metadata = {}, taskId) {
+    return guard(async () => {
+      const ref = getReferenceFromUrl(appName, url);
+
+      let base64String = null;
+
+      switch (format) {
+        case 'base64':
+          base64String = Base64.atob(string);
+          break;
+        case 'base64url':
+          base64String = Base64.atob(string.replace(/_/g, '/').replace(/-/g, '+'));
+          break;
+      }
+
+      const byteArray = new Uint8Array(base64String ? base64String.length : 0);
+
+      if (base64String) {
+        for (let i = 0; i < base64String.length; i++) {
+          byteArray[i] = base64String.charCodeAt(i);
+        }
+      }
+
+      // Start a resumable upload task.
+      const task = uploadBytesResumable(ref, byteArray, {
+        ...makeSettableMetadata(metadata),
+        md5Hash: metadata.md5Hash,
+      });
+
+      // Store the task in the tasks map.
+      tasks[taskId] = task;
+
+      const snapshot = await new Promise((resolve, reject) => {
+        task.on(
+          'state_changed',
+          snapshot => {
+            const event = {
+              body: uploadTaskSnapshotToObject(snapshot),
+              appName,
+              taskId,
+              eventName: 'state_changed',
+            };
+            emitEvent('storage_event', event);
+          },
+          error => {
+            const errorSnapshot = uploadTaskErrorToObject(error, task.snapshot);
+            const event = {
+              body: {
+                ...errorSnapshot,
+                state: 'error',
+              },
+              appName,
+              taskId,
+              eventName: 'state_changed',
+            };
+            emitEvent('storage_event', event);
+            emitEvent('storage_event', {
+              ...event,
+              eventName: 'upload_failure',
+            });
+            delete tasks[taskId];
+            reject(error);
+          },
+          () => {
+            delete tasks[taskId];
+            const event = {
+              body: {
+                ...uploadTaskSnapshotToObject(snapshot),
+                state: 'success',
+              },
+              appName,
+              taskId,
+              eventName: 'state_changed',
+            };
+            emitEvent('storage_event', event);
+            emitEvent('storage_event', {
+              ...event,
+              eventName: 'upload_success',
+            });
+            resolve(task.snapshot);
+          },
+        );
+      });
+
+      return uploadTaskSnapshotToObject(snapshot);
+    });
+  },
+
+  putFile() {
+    return rejectWithCodeAndMessage(
+      'unsupported',
+      'This operation is not supported in this environment.',
+    );
+  },
+
+  /**
+   * Set the status of a task.
+   * @param {string} appName - The app name.
+   * @param {string} taskId - The task ID.
+   * @param {number} status - The status.
+   * @return {Promise<boolean>} Whether the status was set.
+   */
+  setTaskStatus(appName, taskId, status) {
+    // TODO this function implementation cannot
+    // be tested right now since we're unable
+    // to create a big enough upload to be able to
+    // pause/resume/cancel it in time.
+    return guard(async () => {
+      const task = tasks[taskId];
+
+      // If the task doesn't exist, return false.
+      if (!task) {
+        return false;
+      }
+
+      let result = false;
+
+      switch (status) {
+        case 0:
+          result = await task.pause();
+          break;
+        case 1:
+          result = await task.resume();
+          break;
+        case 2:
+          result = await task.cancel();
+          break;
+      }
+
+      emitEvent('storage_event', {
+        data: buildUploadSnapshotMap(task.snapshot),
+        appName,
+        taskId,
+      });
+
+      return result;
+    });
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/storage",
-  "version": "20.1.0",
+  "version": "20.2.1",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - React Native Firebase provides native integration with Cloud Storage, providing support to upload and download files directly from your device and from your Firebase Cloud Storage bucket.",
   "main": "lib/index.js",
@@ -29,10 +29,10 @@
     "download"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "20.1.0"
+    "@react-native-firebase/app": "20.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "99819b9cef23ac46080cbffe50cc85083305d04c"
+  "gitHead": "2c787c2dbefbefcc637018e1e5d74a73b39600ab"
 }