@react-native-firebase/storage 20.0.0 → 20.2.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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
+
 ## [20.0.0](https://github.com/invertase/react-native-firebase/compare/v19.3.0...v20.0.0) (2024-05-20)
 
 **Note:** Version bump only for package @react-native-firebase/storage

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,
@@ -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.0.0';
+module.exports = '20.2.0';

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.0.0",
+  "version": "20.2.0",
   "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.0.0"
+    "@react-native-firebase/app": "20.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b6079dd09ed1f6e47dc782df0d98c5479bfc0cd4"
+  "gitHead": "82c50138d07e673213cd8dee5ce9a2f9b5656649"
 }