@react-native-firebase/storage 20.3.0 → 20.5.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.5.0](https://github.com/invertase/react-native-firebase/compare/v20.4.0...v20.5.0) (2024-09-11)
+
+**Note:** Version bump only for package @react-native-firebase/storage
+
+## [20.4.0](https://github.com/invertase/react-native-firebase/compare/v20.3.0...v20.4.0) (2024-08-13)
+
+### Features
+
+- **firestore:** support for second database ([#7949](https://github.com/invertase/react-native-firebase/issues/7949)) ([eec08a0](https://github.com/invertase/react-native-firebase/commit/eec08a06f41dd96d13778fbed2afcaaac238fca4))
+
 ## [20.3.0](https://github.com/invertase/react-native-firebase/compare/v20.2.1...v20.3.0) (2024-07-19)
 
 **Note:** Version bump only for package @react-native-firebase/storage

package/__tests__/storage.test.ts

@@ -1,6 +1,31 @@
 import { describe, expect, it } from '@jest/globals';
 
-import storage, { firebase } from '../lib';
+import storage, {
+  firebase,
+  getStorage,
+  connectStorageEmulator,
+  ref,
+  deleteObject,
+  getBlob,
+  getBytes,
+  getDownloadURL,
+  getMetadata,
+  getStream,
+  list,
+  listAll,
+  updateMetadata,
+  uploadBytes,
+  uploadBytesResumable,
+  uploadString,
+  refFromURL,
+  setMaxOperationRetryTime,
+  setMaxUploadRetryTime,
+  putFile,
+  writeToFile,
+  toString,
+  child,
+  setMaxDownloadRetryTime,
+} from '../lib';
 
 describe('Storage', function () {
   describe('namespace', function () {
@@ -45,4 +70,98 @@ describe('Storage', function () {
       expect(bar).toEqual(['10.0.2.2', 9000]);
     });
   });
+
+  describe('modular', function () {
+    it('`getStorage` function is properly exposed to end user', function () {
+      expect(getStorage).toBeDefined();
+    });
+
+    it('`connectStorageEmulator` function is properly exposed to end user', function () {
+      expect(connectStorageEmulator).toBeDefined();
+    });
+
+    it('`ref` function is properly exposed to end user', function () {
+      expect(ref).toBeDefined();
+    });
+
+    it('`deleteObject` function is properly exposed to end user', function () {
+      expect(deleteObject).toBeDefined();
+    });
+
+    it('`getBlob` function is properly exposed to end user', function () {
+      expect(getBlob).toBeDefined();
+    });
+
+    it('`getBytes` function is properly exposed to end user', function () {
+      expect(getBytes).toBeDefined();
+    });
+
+    it('`getDownloadURL` function is properly exposed to end user', function () {
+      expect(getDownloadURL).toBeDefined();
+    });
+
+    it('`getMetadata` function is properly exposed to end user', function () {
+      expect(getMetadata).toBeDefined();
+    });
+
+    it('`getStream` function is properly exposed to end user', function () {
+      expect(getStream).toBeDefined();
+    });
+
+    it('`list` function is properly exposed to end user', function () {
+      expect(list).toBeDefined();
+    });
+
+    it('`listAll` function is properly exposed to end user', function () {
+      expect(listAll).toBeDefined();
+    });
+
+    it('`updateMetadata` function is properly exposed to end user', function () {
+      expect(updateMetadata).toBeDefined();
+    });
+
+    it('`uploadBytes` function is properly exposed to end user', function () {
+      expect(uploadBytes).toBeDefined();
+    });
+
+    it('`uploadBytesResumable` function is properly exposed to end user', function () {
+      expect(uploadBytesResumable).toBeDefined();
+    });
+
+    it('`uploadString` function is properly exposed to end user', function () {
+      expect(uploadString).toBeDefined();
+    });
+
+    it('`refFromURL` function is properly exposed to end user', function () {
+      expect(refFromURL).toBeDefined();
+    });
+
+    it('`setMaxOperationRetryTime` function is properly exposed to end user', function () {
+      expect(setMaxOperationRetryTime).toBeDefined();
+    });
+
+    it('`setMaxUploadRetryTime` function is properly exposed to end user', function () {
+      expect(setMaxUploadRetryTime).toBeDefined();
+    });
+
+    it('`putFile` function is properly exposed to end user', function () {
+      expect(putFile).toBeDefined();
+    });
+
+    it('`writeToFile` function is properly exposed to end user', function () {
+      expect(writeToFile).toBeDefined();
+    });
+
+    it('`toString` function is properly exposed to end user', function () {
+      expect(toString).toBeDefined();
+    });
+
+    it('`child` function is properly exposed to end user', function () {
+      expect(child).toBeDefined();
+    });
+
+    it('`setMaxDownloadRetryTime` function is properly exposed to end user', function () {
+      expect(setMaxDownloadRetryTime).toBeDefined();
+    });
+  });
 });

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

@@ -281,7 +281,8 @@ 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, String bucketUrl, 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, bucketUrl);

package/lib/index.d.ts

@@ -1172,3 +1172,5 @@ declare module '@react-native-firebase/app' {
     }
   }
 }
+
+export * from './modular';

package/lib/index.js

@@ -28,31 +28,6 @@ import { getGsUrlParts, getHttpUrlParts, handleStorageEvent } from './utils';
 import version from './version';
 import fallBackModule from './web/RNFBStorageModule';
 
-export {
-  getStorage,
-  connectStorageEmulator,
-  ref,
-  deleteObject,
-  getBlob,
-  getBytes,
-  getDownloadURL,
-  getMetadata,
-  getStream,
-  list,
-  listAll,
-  updateMetadata,
-  putFile,
-  writeToFile,
-  toString,
-  child,
-  setMaxDownloadRetryTime,
-  setMaxOperationRetryTime,
-  setMaxUploadRetryTime,
-  refFromURL,
-  uploadString,
-  uploadBytesResumable,
-} from '../modular/index';
-
 const namespace = 'storage';
 const nativeEvents = ['storage_event'];
 const nativeModuleName = 'RNFBStorageModule';
@@ -233,4 +208,6 @@ export default createModuleNamespace({
 // firebase.storage().X(...);
 export const firebase = getFirebaseRoot();
 
+export * from './modular';
+
 setReactNativeModule(nativeModuleName, fallBackModule);

package/lib/modular/index.d.ts

@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { FirebaseApp } from '@firebase/app-types';
+import { FirebaseStorageTypes } from '../index';
+
+import Storage = FirebaseStorageTypes.Module;
+import Reference = FirebaseStorageTypes.Reference;
+import FullMetadata = FirebaseStorageTypes.FullMetadata;
+import ListResult = FirebaseStorageTypes.ListResult;
+import TaskResult = FirebaseStorageTypes.TaskResult;
+import Task = FirebaseStorageTypes.Task;
+import ListOptions = FirebaseStorageTypes.ListOptions;
+import SettableMetadata = FirebaseStorageTypes.SettableMetadata;
+import EmulatorMockTokenOptions = FirebaseStorageTypes.EmulatorMockTokenOptions;
+
+/**
+ * Returns the existing default {@link Storage} instance that is associated with the
+ * default {@link FirebaseApp}. The default storage bucket is used. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @returns The {@link Storage} instance of the provided app.
+ */
+export declare function getStorage(): Storage;
+
+/**
+ * Returns the existing default {@link Storage} instance that is associated with the
+ * provided {@link FirebaseApp}. The default storage bucket is used. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @param app - The {@link FirebaseApp} instance that the returned {@link Storage}
+ * instance is associated with.
+ * @returns The {@link Firestore} instance of the provided app.
+ */
+export declare function getStorage(app?: FirebaseApp): Storage;
+
+/**
+ * Returns the existing default {@link Storage} instance that is associated with the
+ * provided {@link FirebaseApp}. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @param app - The {@link FirebaseApp} instance that the returned {@link Storage}
+ * instance is associated with. If `null` the default app is used.
+ * @param bucketUrl - The gs:// url to the Firebase Storage Bucket. If `null` the default bucket is used.
+ * @returns The {@link Firestore} instance of the provided app.
+ */
+export declare function getStorage(app?: FirebaseApp, bucketUrl?: string): Storage;
+
+export function getStorage(app?: FirebaseApp, bucketUrl?: string): Storage;
+
+/**
+ * Connects a {@link Storage} instance to the Firebase Storage emulator.
+ * @param storage - A reference to the `Storage` instance.
+ * @param host - Emulator host, e.g., 'localhost'.
+ * @param port - Emulator port, e.g., 9199.
+ * @param options - Optional. {@link EmulatorMockTokenOptions} instance.
+ */
+export function connectStorageEmulator(
+  storage: Storage,
+  host: string,
+  port: number,
+  options?: EmulatorMockTokenOptions,
+): void;
+
+/**
+ * Creates a {@link Reference} from a given path or URL.
+ * @param storage - The {@link Storage} instance.
+ * @param path - Optional. A string pointing to a location within the storage bucket.
+ * @returns A new {@link Reference}.
+ */
+export function ref(storage: Storage, path?: string): Reference;
+
+/**
+ * Deletes the object at the given reference's location.
+ * @param storageRef - The {@link Reference} to the object to delete.
+ * @returns A promise that resolves when the delete is complete.
+ */
+export function deleteObject(storageRef: Reference): Promise<void>;
+
+/**
+ * Retrieves the blob at the given reference's location. Throws an error if the object is not found.
+ * @param storageRef - The {@link Reference} to the object.
+ * @returns A promise resolving to the Blob.
+ */
+export function getBlob(storageRef: Reference): Promise<Blob>;
+
+/**
+ * Retrieves bytes (up to the specified max size) from an object at the given reference's location.
+ * Throws an error if the object is not found or if the size exceeds the maximum allowed.
+ * @param storageRef - The {@link Reference} to the object.
+ * @param maxDownloadSizeBytes - Maximum size in bytes to retrieve.
+ * @returns A promise resolving to an ArrayBuffer.
+ */
+export function getBytes(storageRef: Reference, maxDownloadSizeBytes: number): Promise<ArrayBuffer>;
+
+/**
+ * Retrieves a long-lived download URL for the object at the given reference's location.
+ * @param storageRef - The {@link Reference} to the object.
+ * @returns A promise resolving to the URL string.
+ */
+export function getDownloadURL(storageRef: Reference): Promise<string>;
+
+/**
+ * Retrieves metadata for the object at the given reference's location.
+ * @param storageRef - The {@link Reference} to the object.
+ * @returns A promise resolving to the object's {@link FullMetadata}.
+ */
+export function getMetadata(storageRef: Reference): Promise<FullMetadata>;
+
+/**
+ * Retrieves a readable stream for the object at the given reference's location. This API is only available in Node.js.
+ * @param storageRef - The {@link Reference} to the object.
+ * @param maxDownloadSizeBytes - Maximum size in bytes to retrieve.
+ * @returns A NodeJS ReadableStream.
+ */
+export function getStream(
+  storageRef: Reference,
+  maxDownloadSizeBytes: number,
+): NodeJS.ReadableStream;
+
+/**
+ * Lists items and prefixes under the given reference.
+ * @param storageRef - The {@link Reference} under which to list items.
+ * @param options - Optional. Configuration for listing.
+ * @returns A promise resolving to a {@link ListResult}.
+ */
+export function list(storageRef: Reference, options?: ListOptions): Promise<ListResult>;
+
+/**
+ * Lists all items and prefixes under the given reference.
+ * @param storageRef - The {@link Reference} under which to list items.
+ * @returns A promise resolving to a {@link ListResult}.
+ */
+export function listAll(storageRef: Reference): Promise<ListResult>;
+
+/**
+ * Updates metadata for the object at the given reference.
+ * @param storageRef - The {@link Reference} to the object.
+ * @param metadata - The metadata to update.
+ * @returns A promise resolving to the updated {@link FullMetadata}.
+ */
+export function updateMetadata(
+  storageRef: Reference,
+  metadata: SettableMetadata,
+): Promise<FullMetadata>;
+
+/**
+ * Uploads data to the object's location at the given reference. The upload is not resumable.
+ * @param storageRef - The {@link Reference} where the data should be uploaded.
+ * @param data - The data to upload.
+ * @param metadata - Optional. Metadata to associate with the uploaded object.
+ * @returns A promise resolving to a {@link TaskResult}.
+ */
+export function uploadBytes(
+  storageRef: Reference,
+  data: Blob | Uint8Array | ArrayBuffer,
+  metadata?: SettableMetadata,
+): Promise<TaskResult>;
+
+/**
+ * Initiates a resumable upload session for the data to the object's location at the given reference.
+ * @param storageRef - The {@link Reference} where the data should be uploaded.
+ * @param data - The data to upload.
+ * @param metadata - Optional. Metadata to associate with the uploaded object.
+ * @returns A {@link Task} associated with the upload process.
+ */
+export function uploadBytesResumable(
+  storageRef: Reference,
+  data: Blob | Uint8Array | ArrayBuffer,
+  metadata?: SettableMetadata,
+): Task;
+
+/**
+ * Uploads a string to the object's location at the given reference. The string format must be specified.
+ * @param storageRef - The {@link Reference} where the string should be uploaded.
+ * @param data - The string data to upload.
+ * @param format - Optional. The format of the string ('raw', 'base64', 'base64url', 'data_url').
+ * @param metadata - Optional. Metadata to associate with the uploaded object.
+ * @returns A {@link Task} associated with the upload process.
+ */
+export function uploadString(
+  storageRef: Reference,
+  data: string,
+  format?: 'raw' | 'base64' | 'base64url' | 'data_url',
+  metadata?: SettableMetadata,
+): Task;
+
+/**
+ * Creates a {@link Reference} from a storage bucket URL.
+ * @param storage - The {@link Storage} instance.
+ * @param url - A URL pointing to a file or location in a storage bucket.
+ * @returns A {@link Reference} pointing to the specified URL.
+ */
+export function refFromURL(storage: Storage, url: string): Reference;
+
+/**
+ * Sets the maximum time in milliseconds to retry operations other than upload and download if a failure occurs.
+ * @param storage - The {@link Storage} instance.
+ * @param time - The new maximum operation retry time in milliseconds.
+ */
+export function setMaxOperationRetryTime(storage: Storage, time: number): Promise<void>;
+
+/**
+ * Sets the maximum time in milliseconds to retry upload operations if a failure occurs.
+ * @param storage - The {@link Storage} instance.
+ * @param time - The new maximum upload retry time in milliseconds.
+ */
+export function setMaxUploadRetryTime(storage: Storage, time: number): Promise<void>;
+
+/**
+ * Puts a file from a local disk onto the storage bucket at the given reference.
+ * @param storageRef - The {@link Reference} where the file should be uploaded.
+ * @param filePath - The local file path of the file to upload.
+ * @param metadata - Optional. Metadata to associate with the uploaded file.
+ * @returns A {@link Task} associated with the upload process.
+ */
+export function putFile(storageRef: Reference, filePath: string, metadata?: SettableMetadata): Task;
+
+/**
+ * Downloads a file to the specified local file path on the device.
+ * @param storageRef - The {@link Reference} from which the file should be downloaded.
+ * @param filePath - The local file path where the file should be written.
+ * @returns A {@link Task} associated with the download process.
+ */
+export function writeToFile(storageRef: Reference, filePath: string): Task;
+
+/**
+ * Returns a gs:// URL for the object at the given reference.
+ * @param storageRef - The {@link Reference} to the object.
+ * @returns The URL as a string.
+ */
+export function toString(storageRef: Reference): string;
+
+/**
+ * Returns a reference to a relative path from the given reference.
+ * @param storageRef - The {@link Reference} as the base.
+ * @param path - The relative path from the base reference.
+ * @returns A new {@link Reference}.
+ */
+export function child(storageRef: Reference, path: string): Reference;
+
+/**
+ * Sets the maximum time in milliseconds to retry download operations if a failure occurs.
+ * @param storage - The {@link Storage} instance.
+ * @param time - The new maximum download retry time in milliseconds.
+ */
+export function setMaxDownloadRetryTime(storage: Storage, time: number): Promise<void>;

package/{modular → lib/modular}/index.js

@@ -14,6 +14,19 @@
  * limitations under the License.
  *
  */
+/**
+ * @typedef {import('..').FirebaseStorageTypes} FirebaseStorageTypes
+ * @typedef {import('..').FirebaseStorageTypes.Module} Storage
+ * @typedef {import('..').FirebaseStorageTypes.Reference} Reference
+ * @typedef {import('..').FirebaseStorageTypes.FullMetadata} FullMetadata
+ * @typedef {import('..').FirebaseStorageTypes.ListResult} ListResult
+ * @typedef {import('..').FirebaseStorageTypes.TaskResult} TaskResult
+ * @typedef {import('..').FirebaseStorageTypes.Task} Task
+ * @typedef {import('..').FirebaseStorageTypes.ListOptions} ListOptions
+ * @typedef {import('..').FirebaseStorageTypes.SettableMetadata} SettableMetadata
+ * @typedef {import('..').FirebaseStorageTypes.EmulatorMockTokenOptions} EmulatorMockTokenOptions
+ * @typedef {import('@firebase/app').FirebaseApp} FirebaseApp
+ */
 
 import { firebase } from '..';
 
@@ -56,7 +69,7 @@ export function connectStorageEmulator(storage, host, port, options) {
  * @param storage - Storage instance.
  * @param path An optional string pointing to a location on the storage bucket. If no path
  * is provided, the returned reference will be the bucket root path. Optional.
- * @returns {Storage.Reference}
+ * @returns {Reference}
  */
 export function ref(storage, path) {
   return storage.ref(path);

package/lib/version.js

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

package/lib/web/RNFBStorageModule.js

@@ -120,32 +120,48 @@ const storageInstances = {};
 const tasks = {};
 
 function getBucketFromUrl(url) {
-  const pathWithBucketName = url.substring(5);
-  const bucket = url.substring(0, pathWithBucketName.indexOf('/') + 5);
-  return bucket;
+  // Check if the URL starts with "gs://"
+  if (url.startsWith('gs://')) {
+    // Return the bucket name by extracting everything up to the first slash after "gs://"
+    // and removing the "gs://" prefix
+    return url.substring(5).split('/')[0];
+  } else {
+    // Assume the URL is a path format, strip the leading slash if it exists and extract the bucket name
+    const strippedUrl = url.startsWith('/') ? url.substring(1) : url;
+    // Extract the bucket from the path, assuming it ends at the first slash after the domain
+    return strippedUrl.split('/')[0];
+  }
 }
 
 function getCachedAppInstance(appName) {
   return (appInstances[appName] ??= getApp(appName));
 }
 
+function emulatorKey(appName, url) {
+  const bucket = getBucketFromUrl(url);
+  return `${appName}|${bucket}`;
+}
+
 // Returns a cached Storage instance.
 function getCachedStorageInstance(appName, url) {
   let instance;
+  const bucket = url ? getBucketFromUrl(url) : getCachedAppInstance(appName).options.storageBucket;
+
   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);
+
+  const key = emulatorKey(appName, bucket);
+  if (emulatorForApp[key]) {
+    connectStorageEmulator(instance, emulatorForApp[key].host, emulatorForApp[key].port);
   }
   return instance;
 }
@@ -296,11 +312,12 @@ export default {
    * @param {number} port - The emulator port.
    * @return {Promise<void>}
    */
-  useEmulator(appName, host, port) {
+  useEmulator(appName, host, port, url) {
     return guard(async () => {
-      const instance = getCachedStorageInstance(appName);
+      const instance = getCachedStorageInstance(appName, url);
       connectStorageEmulator(instance, host, port);
-      emulatorForApp[appName] = { host, port };
+      const key = emulatorKey(appName, url);
+      emulatorForApp[key] = { host, port };
     });
   },
 
@@ -324,28 +341,23 @@ export default {
   putString(appName, url, string, format, metadata = {}, taskId) {
     return guard(async () => {
       const ref = getReferenceFromUrl(appName, url);
+      let decodedString = null;
 
-      let base64String = null;
-
+      // This is always either base64 or base64url
       switch (format) {
         case 'base64':
-          base64String = Base64.atob(string);
+          decodedString = Base64.atob(string);
           break;
         case 'base64url':
-          base64String = Base64.atob(string.replace(/_/g, '/').replace(/-/g, '+'));
+          decodedString = Base64.atob(string.replace(/_/g, '/').replace(/-/g, '+'));
           break;
       }
 
-      const byteArray = new Uint8Array(base64String ? base64String.length : 0);
+      const encoder = new TextEncoder();
 
-      if (base64String) {
-        for (let i = 0; i < base64String.length; i++) {
-          byteArray[i] = base64String.charCodeAt(i);
-        }
-      }
+      const arrayBuffer = encoder.encode(decodedString).buffer;
 
-      // Start a resumable upload task.
-      const task = uploadBytesResumable(ref, byteArray, {
+      const task = uploadBytesResumable(ref, arrayBuffer, {
         ...makeSettableMetadata(metadata),
         md5Hash: metadata.md5Hash,
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/storage",
-  "version": "20.3.0",
+  "version": "20.5.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.3.0"
+    "@react-native-firebase/app": "20.5.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a916b37b022cf40588fa0fd915b7ab901e2458d0"
+  "gitHead": "daf2bc9086c14bbb0e1b02a4d4274b7060263eb1"
 }