fix(storage): uploadBytes now with upstream types, tests

Author: mikehardy

.github/scripts/compare-types/packages/storage/config.ts

@@ -166,13 +166,6 @@ const config: PackageConfig = {
         '(the Web Streams API type). The Node.js stream type is used because the ' +
         'React Native environment does not have the Web Streams API.',
     },
-    {
-      name: 'uploadBytes',
-      reason:
-        'Returns `Promise<TaskResult>` in RN Firebase instead of `Promise<UploadResult>`. ' +
-        '`TaskResult` is a type alias for `UploadResult`, so the runtime shape is identical; ' +
-        'the different name is for consistency with the native task system.',
-    },
     {
       name: 'uploadBytesResumable',
       reason:

packages/storage/e2e/StorageTask.e2e.js

@@ -1070,6 +1070,45 @@ describe('storage() -> StorageTask', function () {
       });
     });
 
+    describe('uploadBytes()', function () {
+      it('resolves with ref and metadata whose size matches uploaded bytes', async function () {
+        const { getStorage, ref, uploadBytes } = storageModular;
+        const jsonDerulo = JSON.stringify({ foo: 'bar' });
+        const expectedByteLength = jsonDerulo.length;
+
+        const arrayBuffer = new ArrayBuffer(jsonDerulo.length);
+        const arrayBufferView = new Uint8Array(arrayBuffer);
+
+        for (let i = 0, strLen = jsonDerulo.length; i < strLen; i++) {
+          arrayBufferView[i] = jsonDerulo.charCodeAt(i);
+        }
+
+        const uploadResult = await uploadBytes(
+          ref(getStorage(), `${PATH}/uploadBytesModular.json`),
+          arrayBuffer,
+          {
+            contentType: 'application/json',
+          },
+        );
+
+        uploadResult.ref.fullPath.should.containEql('uploadBytesModular.json');
+        uploadResult.metadata.should.be.an.Object();
+        uploadResult.metadata.size.should.eql(expectedByteLength);
+        uploadResult.metadata.contentType.should.eql('application/json');
+      });
+
+      it('rejects when metadata is not an object', async function () {
+        const { getStorage, ref, uploadBytes } = storageModular;
+        try {
+          await uploadBytes(ref(getStorage(), `${PATH}/uploadBytesBadMeta.json`), new ArrayBuffer(), 123);
+          return Promise.reject(new Error('Did not error!'));
+        } catch (error) {
+          error.message.should.containEql('must be an object value');
+          return Promise.resolve();
+        }
+      });
+    });
+
     describe('upload tasks', function () {
       // before(async function () {
       //   // TODO we need some semi-large assets to upload and download I think?

packages/storage/lib/modular.ts

@@ -17,18 +17,19 @@
 
 import { getApp } from '@react-native-firebase/app';
 import { MODULAR_DEPRECATION_ARG } from '@react-native-firebase/app/dist/module/common';
+import { NativeFirebaseError } from '@react-native-firebase/app/dist/module/internal';
 import type { FirebaseApp } from '@react-native-firebase/app';
 import type {
   FirebaseStorage,
   StorageReference,
   FullMetadata,
   ListResult,
   ListOptions,
-  TaskResult,
   Task,
   SettableMetadata,
   UploadMetadata,
   EmulatorMockTokenOptions,
+  UploadResult,
 } from './types/storage';
 import { TaskEvent, TaskState } from './types/storage';
 import type { StorageReferenceInternal, StorageInternal } from './types/internal';
@@ -269,43 +270,67 @@ export function updateMetadata(
 
 /**
  * Uploads data to this object's location. The upload is not resumable. If the upload is canceled,
- * the Promise will reject with the TaskSnapshot. If there is an error it will reject with the StorageError
+ * the Promise rejects with a {@link NativeFirebaseError} (typically `storage/cancelled`),
+ * matching other storage upload tasks. Other failures reject with the same error type as {@link uploadBytesResumable}.
  * @param storageRef - Storage `Reference` instance.
  * @param data - The data (Blob | Uint8Array | ArrayBuffer) to upload to the storage bucket at the reference location.
  * @param metadata - A Storage `UploadMetadata` instance to update. Optional.
- * @returns {Promise<TaskResult>}
+ * @returns {Promise<UploadResult>}
  */
 export async function uploadBytes(
   storageRef: StorageReference,
   data: Blob | Uint8Array | ArrayBuffer,
   metadata?: UploadMetadata,
-): Promise<TaskResult> {
+): Promise<UploadResult> {
   const task = uploadBytesResumable(storageRef, data, metadata);
   return new Promise((resolve, reject) => {
-    task.on(
+    let completed = false;
+    const subscription: { unsubscribe?: () => void } = {};
+
+    const settle = (fn: () => void) => {
+      if (completed) {
+        return;
+      }
+      completed = true;
+      subscription.unsubscribe?.();
+      fn();
+    };
+
+    subscription.unsubscribe = task.on(
       TaskEvent.STATE_CHANGED,
       taskSnapshot => {
         switch (taskSnapshot.state) {
           case TaskState.RUNNING:
             break;
           case TaskState.PAUSED:
+            // we are wrapping the resumable version, just resume if it pauses
             task.resume();
             break;
           case TaskState.SUCCESS:
-            resolve({ ref: taskSnapshot.ref, metadata: taskSnapshot.metadata });
+            settle(() => resolve({ ref: taskSnapshot.ref, metadata: taskSnapshot.metadata }));
             break;
           case TaskState.CANCELED:
-            // The TaskSnapshot may be useful to have if we reject due to cancel
-            reject(taskSnapshot);
+            settle(() =>
+              reject(
+                NativeFirebaseError.fromEvent(
+                  { code: 'cancelled', message: 'User cancelled the operation.' },
+                  'storage',
+                ),
+              ),
+            );
             break;
           case TaskState.ERROR:
-            // this will be handled in the dedicated error listener
+            // this is handled in the dedicated error listener below
             break;
           default:
-            throw new Error(`Unhandled task state in uploadBytes: ${taskSnapshot.state}`);
+            settle(() =>
+              reject(new Error(`Unhandled task state in uploadBytes: ${taskSnapshot.state}`)),
+            );
         }
       },
-      error => reject(error),
+      error => {
+        settle(() => reject(error));
+      },
     );
   });
 }

packages/storage/type-test.ts

@@ -3,6 +3,7 @@ import storage, {
   // Types
   type FirebaseStorage,
   type FirebaseStorageTypes,
+  type StorageReference,
   // Modular API
   getStorage,
   connectStorageEmulator,
@@ -234,10 +235,20 @@ updateMetadata(modularRef1, { cacheControl: 'no-cache' }).then(
 
 uploadBytes(modularRef1, new Blob(), { cacheControl: 'no-cache' }).then(
   (result: TaskResult) => {
-    console.log(result);
+    const uploadBytesRef: StorageReference = result.ref;
+    const uploadBytesMeta: FullMetadata = result.metadata;
+    console.log(uploadBytesRef.fullPath, uploadBytesMeta.size);
   },
 );
 
+uploadBytes(modularRef1, new Uint8Array([1, 2, 3])).then((result: TaskResult) => {
+  console.log(result.ref.name, result.metadata.size);
+});
+
+uploadBytes(modularRef1, new ArrayBuffer(0)).then((result: TaskResult) => {
+  console.log(result.metadata.fullPath);
+});
+
 const modularUploadBytesResumable = uploadBytesResumable(modularRef1, new Blob(), {
   cacheControl: 'no-cache',
 });