Fix map()

packages/firestore/src/local/persistence_promise.ts

@@ -200,10 +200,26 @@ export class PersistencePromise<T> {
 
   static map<R>(all: Iterable<PersistencePromise<R>>): PersistencePromise<R[]> {
     const results: R[] = [];
-    return PersistencePromise.forEach(all, result => {
-      results.push(result);
-      return PersistencePromise.resolve();
-    }).next(() => results);
+    const promises: Array<PersistencePromise<void>> = [];
+
+    const it = all[Symbol.iterator]();
+    let result = it.next();
+    let count = 0;
+    while (!result.done) {
+      const value = result.value;
+      const index = count;
+
+      promises.push(
+        value.next(val => {
+          results[index] = val;
+        })
+      );
+
+      result = it.next();
+      ++count;
+    }
+
+    return PersistencePromise.waitFor(promises).next(() => results);
   }
 
   static forEach<T>(

packages/firestore/test/unit/local/persistence_promise.test.ts

@@ -16,6 +16,12 @@
 
 import { expect } from 'chai';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
+import { Deferred } from '../../../src/util/promise';
+
+import * as chai from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+
+chai.use(chaiAsPromised);
 
 describe('PersistencePromise', () => {
   function async<R>(value: R): PersistencePromise<R> {
@@ -214,6 +220,17 @@ describe('PersistencePromise', () => {
       .toPromise();
   });
 
+  it('propagates error for waitFor()', () => {
+    const resolved = PersistencePromise.resolve('resolved');
+    const rejected: PersistencePromise<string> = PersistencePromise.reject(
+      new Error('rejected')
+    );
+
+    const p = PersistencePromise.waitFor([resolved, rejected]).toPromise();
+
+    return expect(p).to.be.eventually.rejectedWith('rejected');
+  });
+
   it('executes forEach in order', async () => {
     let result = '';
     await PersistencePromise.forEach(['a', 'b', 'c'], el => {
@@ -222,4 +239,46 @@ describe('PersistencePromise', () => {
     }).toPromise();
     expect(result).to.equal('abc');
   });
+
+  it('propagates error for forEach()', () => {
+    const p = PersistencePromise.forEach([true, false], success => {
+      if (success) {
+        return PersistencePromise.resolve();
+      } else {
+        return PersistencePromise.reject(new Error('rejected'));
+      }
+    }).toPromise();
+
+    return expect(p).to.be.eventually.rejectedWith('rejected');
+  });
+
+  it('maintains order for map()', async () => {
+    const deferred = new Deferred<void>();
+
+    const pending = new PersistencePromise<string>(resolve => {
+      return deferred.promise.then(() => resolve('first'));
+    });
+    const resolved = PersistencePromise.resolve('second');
+
+    const p = PersistencePromise.map([pending, resolved]).next(results => {
+      expect(results).to.deep.eq(['first', 'second']);
+      return PersistencePromise.resolve();
+    });
+
+    setImmediate(() => {
+      deferred.resolve();
+    });
+
+    await p.toPromise();
+  });
+
+  it('propagates error for map()', () => {
+    const resolved = PersistencePromise.resolve('resolved');
+    const rejected: PersistencePromise<string> = PersistencePromise.reject(
+      new Error('rejected')
+    );
+
+    const p = PersistencePromise.map([resolved, rejected]).toPromise();
+    return expect(p).to.be.eventually.rejectedWith('rejected');
+  });
 });

packages/firestore/test/unit/local/simple_db.test.ts

@@ -488,7 +488,7 @@ describe('SimpleDb', () => {
         for (let i = 0; i < 1000; ++i) {
           promises.push(store.get(i));
         }
-        return PersistencePromise.map(promises).next(() => {
+        return PersistencePromise.waitFor(promises).next(() => {
           const end = new Date().getTime();
           // tslint:disable-next-line:no-console
           console.log(`Reading: ${end - start} ms`);