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

@@ -24,11 +24,11 @@ import type {
   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,17 +269,18 @@ 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 will reject with the {TaskSnapshot}. If there is an error it will reject with the StorageError,
+ * but as a {ReactNativeFirebase.NativeFirebaseError} type
  * @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(
@@ -289,6 +290,7 @@ export async function uploadBytes(
           case TaskState.RUNNING:
             break;
           case TaskState.PAUSED:
+            // we are wrapping the resumable version, just resume if it pauses
             task.resume();
             break;
           case TaskState.SUCCESS:
@@ -299,7 +301,7 @@ export async function uploadBytes(
             reject(taskSnapshot);
             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}`);

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',
 });