Remove some object utility functions

Author: mmermerkaya

config/tsconfig.base.json

@@ -8,6 +8,7 @@
     "moduleResolution": "node",
     "sourceMap": true,
     "target": "es5",
+    "downlevelIteration": true,
     "typeRoots": ["../node_modules/@types"]
   }
 }

packages/database/src/core/CompoundWrite.ts

@@ -17,7 +17,6 @@
 
 import { ImmutableTree } from './util/ImmutableTree';
 import { Path } from './util/Path';
-import { forEach } from '@firebase/util';
 import { Node, NamedNode } from './snap/Node';
 import { PRIORITY_INDEX } from './snap/indexes/PriorityIndex';
 import { assert } from '@firebase/util';
@@ -70,9 +69,9 @@ export class CompoundWrite {
    */
   addWrites(path: Path, updates: { [name: string]: Node }): CompoundWrite {
     let newWrite = this as CompoundWrite;
-    forEach(updates, function(childKey: string, node: Node) {
+    for (const [childKey, node] of Object.entries(updates)) {
       newWrite = newWrite.addWrite(path.child(childKey), node);
-    });
+    }
     return newWrite;
   }
 

packages/database/src/core/PersistentConnection.ts

@@ -16,7 +16,7 @@
  */
 
 import firebase from '@firebase/app';
-import { forEach, contains, isEmpty, getCount, safeGet } from '@firebase/util';
+import { contains, isEmpty, safeGet } from '@firebase/util';
 import { stringify } from '@firebase/util';
 import { assert } from '@firebase/util';
 import { error, log, logWrapper, warn, ObjectToUniqueKey } from './util/util';
@@ -901,7 +901,7 @@ export class PersistentConnection extends ServerActions {
     if (this.listens_[normalizedPathString] !== undefined) {
       listen = this.listens_[normalizedPathString][queryId];
       delete this.listens_[normalizedPathString][queryId];
-      if (getCount(this.listens_[normalizedPathString]) === 0) {
+      if (isEmpty(this.listens_[normalizedPathString])) {
         delete this.listens_[normalizedPathString];
       }
     } else {
@@ -948,11 +948,11 @@ export class PersistentConnection extends ServerActions {
 
     // Puts depend on having received the corresponding data update from the server before they complete, so we must
     // make sure to send listens before puts.
-    forEach(this.listens_, (_pathString, queries) => {
-      forEach(queries, (_key, listenSpec) => {
+    for (const queries of Object.values(this.listens_)) {
+      for (const listenSpec of Object.values(queries)) {
         this.sendListen_(listenSpec);
-      });
-    });
+      }
+    }
 
     for (let i = 0; i < this.outstandingPuts_.length; i++) {
       if (this.outstandingPuts_[i]) this.sendPut_(i);

packages/database/src/core/Repo.ts

@@ -27,7 +27,7 @@ import { SyncTree } from './SyncTree';
 import { SnapshotHolder } from './SnapshotHolder';
 import { stringify } from '@firebase/util';
 import { beingCrawled, each, exceptionGuard, warn, log } from './util/util';
-import { map, forEach, isEmpty } from '@firebase/util';
+import { map, isEmpty } from '@firebase/util';
 import { AuthTokenProvider } from './AuthTokenProvider';
 import { StatsManager } from './stats/StatsManager';
 import { StatsReporter } from './stats/StatsReporter';
@@ -403,14 +403,14 @@ export class Repo {
     let empty = true;
     const serverValues = this.generateServerValues();
     const changedChildren: { [k: string]: Node } = {};
-    forEach(childrenToMerge, (changedKey: string, changedValue: any) => {
+    for (const [changedKey, changedValue] of Object.entries(childrenToMerge)) {
       empty = false;
       const newNodeUnresolved = nodeFromJSON(changedValue);
       changedChildren[changedKey] = resolveDeferredValueSnapshot(
         newNodeUnresolved,
         serverValues
       );
-    });
+    }
 
     if (!empty) {
       const writeId = this.getNextWriteId_();
@@ -440,10 +440,10 @@ export class Repo {
         }
       );
 
-      forEach(childrenToMerge, (changedPath: string) => {
+      for (const changedPath of Object.keys(childrenToMerge)) {
         const affectedPath = this.abortTransactions_(path.child(changedPath));
         this.rerunTransactions_(affectedPath);
-      });
+      }
 
       // We queued the events above, so just flush the queue here
       this.eventQueue_.raiseEventsForChangedPath(path, []);
@@ -566,10 +566,12 @@ export class Repo {
       childrenToMerge,
       (status, errorReason) => {
         if (status === 'ok') {
-          forEach(childrenToMerge, (childName: string, childNode: any) => {
+          for (const [childName, childNode] of Object.entries(
+            childrenToMerge
+          )) {
             const newChildNode = nodeFromJSON(childNode);
             this.onDisconnect_.remember(path.child(childName), newChildNode);
-          });
+          }
         }
         this.callOnCompleteCallback(onComplete, status, errorReason);
       }
@@ -651,11 +653,14 @@ export class Repo {
       0
     );
 
-    forEach(stats, (stat: string, value: any) => {
+    for (const [stat, value] of Object.entries(stats)) {
+      let paddedStat = stat;
       // pad stat names to be the same length (plus 2 extra spaces).
-      for (let i = stat.length; i < longestName + 2; i++) stat += ' ';
-      console.log(stat + value);
-    });
+      for (let i = stat.length; i < longestName + 2; i++) {
+        paddedStat += ' ';
+      }
+      console.log(paddedStat + value);
+    }
   }
 
   statsIncrementCounter(metric: string) {

packages/database/src/core/RepoInfo.ts

@@ -16,7 +16,6 @@
  */
 
 import { assert } from '@firebase/util';
-import { forEach } from '@firebase/util';
 import { PersistentStorage } from './storage/storage';
 import { LONG_POLLING, WEBSOCKET } from '../realtime/Constants';
 
@@ -102,9 +101,9 @@ export class RepoInfo {
 
     const pairs: string[] = [];
 
-    forEach(params, (key: string, value: string) => {
+    for (const [key, value] of Object.entries(params)) {
       pairs.push(key + '=' + value);
-    });
+    }
 
     return connURL + pairs.join('&');
   }

packages/database/src/core/SyncPoint.ts

@@ -18,7 +18,6 @@
 import { CacheNode } from './view/CacheNode';
 import { ChildrenNode } from './snap/ChildrenNode';
 import { assert } from '@firebase/util';
-import { isEmpty, forEach, findValue, safeGet } from '@firebase/util';
 import { ViewCache } from './view/ViewCache';
 import { View } from './view/View';
 import { Operation } from './operation/Operation';
@@ -61,34 +60,21 @@ export class SyncPoint {
    * queryId and the value is the View for that query.
    *
    * NOTE: This list will be quite small (usually 1, but perhaps 2 or 3; any more is an odd use case).
-   *
-   * @type {!Object.<!string, !View>}
-   * @private
    */
-  private views_: { [k: string]: View } = {};
+  private readonly views: Map<string, View> = new Map();
 
-  /**
-   * @return {boolean}
-   */
   isEmpty(): boolean {
-    return isEmpty(this.views_);
+    return this.views.size === 0;
   }
 
-  /**
-   *
-   * @param {!Operation} operation
-   * @param {!WriteTreeRef} writesCache
-   * @param {?Node} optCompleteServerCache
-   * @return {!Array.<!Event>}
-   */
   applyOperation(
     operation: Operation,
     writesCache: WriteTreeRef,
     optCompleteServerCache: Node | null
   ): Event[] {
     const queryId = operation.source.queryId;
     if (queryId !== null) {
-      const view = safeGet(this.views_, queryId);
+      const view = this.views.get(queryId);
       assert(view != null, 'SyncTree gave us an op for an invalid query.');
       return view.applyOperation(
         operation,
@@ -98,11 +84,11 @@ export class SyncPoint {
     } else {
       let events: Event[] = [];
 
-      forEach(this.views_, function(key: string, view: View) {
+      for (const view of this.views.values()) {
         events = events.concat(
           view.applyOperation(operation, writesCache, optCompleteServerCache)
         );
-      });
+      }
 
       return events;
     }
@@ -126,7 +112,7 @@ export class SyncPoint {
     serverCacheComplete: boolean
   ): Event[] {
     const queryId = query.queryIdentifier();
-    let view = safeGet(this.views_, queryId);
+    let view = this.views.get(queryId);
     if (!view) {
       // TODO: make writesCache take flag for complete server node
       let eventCache = writesCache.calcCompleteEventCache(
@@ -155,7 +141,7 @@ export class SyncPoint {
         )
       );
       view = new View(query, viewCache);
-      this.views_[queryId] = view;
+      this.views.set(queryId, view);
     }
 
     // This is guaranteed to exist now, we just created anything that was missing
@@ -185,13 +171,12 @@ export class SyncPoint {
     const hadCompleteView = this.hasCompleteView();
     if (queryId === 'default') {
       // When you do ref.off(...), we search all views for the registration to remove.
-      const self = this;
-      forEach(this.views_, function(viewQueryId: string, view: View) {
+      for (const [viewQueryId, view] of this.views.entries()) {
         cancelEvents = cancelEvents.concat(
           view.removeEventRegistration(eventRegistration, cancelError)
         );
         if (view.isEmpty()) {
-          delete self.views_[viewQueryId];
+          this.views.delete(viewQueryId);
 
           // We'll deal with complete views later.
           if (
@@ -203,16 +188,16 @@ export class SyncPoint {
             removed.push(view.getQuery());
           }
         }
-      });
+      }
     } else {
       // remove the callback from the specific view.
-      const view = safeGet(this.views_, queryId);
+      const view = this.views.get(queryId);
       if (view) {
         cancelEvents = cancelEvents.concat(
           view.removeEventRegistration(eventRegistration, cancelError)
         );
         if (view.isEmpty()) {
-          delete this.views_[queryId];
+          this.views.delete(queryId);
 
           // We'll deal with complete views later.
           if (
@@ -237,66 +222,48 @@ export class SyncPoint {
     return { removed: removed, events: cancelEvents };
   }
 
-  /**
-   * @return {!Array.<!View>}
-   */
   getQueryViews(): View[] {
-    const values = Object.keys(this.views_).map(key => this.views_[key]);
-    return values.filter(function(view) {
-      return !view
-        .getQuery()
-        .getQueryParams()
-        .loadsAllData();
-    });
+    return Array.from(this.views.values()).filter(
+      view =>
+        !view
+          .getQuery()
+          .getQueryParams()
+          .loadsAllData()
+    );
   }
 
   /**
-   *
-   * @param {!Path} path The path to the desired complete snapshot
-   * @return {?Node} A complete cache, if it exists
+   * @param path The path to the desired complete snapshot
+   * @return A complete cache, if it exists
    */
   getCompleteServerCache(path: Path): Node | null {
     let serverCache: Node | null = null;
-    forEach(this.views_, (key: string, view: View) => {
+    for (const view of this.views.values()) {
       serverCache = serverCache || view.getCompleteServerCache(path);
-    });
+    }
     return serverCache;
   }
 
-  /**
-   * @param {!Query} query
-   * @return {?View}
-   */
   viewForQuery(query: Query): View | null {
     const params = query.getQueryParams();
     if (params.loadsAllData()) {
       return this.getCompleteView();
     } else {
       const queryId = query.queryIdentifier();
-      return safeGet(this.views_, queryId);
+      return this.views.get(queryId);
     }
   }
 
-  /**
-   * @param {!Query} query
-   * @return {boolean}
-   */
   viewExistsForQuery(query: Query): boolean {
     return this.viewForQuery(query) != null;
   }
 
-  /**
-   * @return {boolean}
-   */
   hasCompleteView(): boolean {
     return this.getCompleteView() != null;
   }
 
-  /**
-   * @return {?View}
-   */
   getCompleteView(): View | null {
-    const completeView = findValue(this.views_, (view: View) =>
+    const completeView = Array.from(this.views.values()).find((view: View) =>
       view
         .getQuery()
         .getQueryParams()