refactor(database): Several classes and utility methods

Author: jsayol

src/database/api/DataSnapshot.ts

@@ -112,7 +112,7 @@ export class DataSnapshot {
    * @return {boolean} True if forEach was canceled by action returning true for
    * one of the child nodes.
    */
-  forEach(action: (d: DataSnapshot) => any): boolean {
+  forEach(action: (d: DataSnapshot) => void): boolean {
     validateArgCount('DataSnapshot.forEach', 1, 1, arguments.length);
     validateCallback('DataSnapshot.forEach', 1, action, false);
 

src/database/api/Database.ts

@@ -1,81 +1,81 @@
-import { fatal } from "../core/util/util";
-import { parseRepoInfo } from "../core/util/libs/parser";
-import { Path } from "../core/util/Path";
-import { PromiseImpl } from "../../utils/promise";
-import { Reference } from "./Reference";
-import { Repo } from "../core/Repo";
-import { RepoManager } from "../core/RepoManager";
-import { validateArgCount } from "../../utils/validation";
-import { validateUrl } from "../core/util/validation";
+import { fatal } from '../core/util/util';
+import { parseRepoInfo } from '../core/util/libs/parser';
+import { Path } from '../core/util/Path';
+import { PromiseImpl } from '../../utils/promise';
+import { Reference } from './Reference';
+import { Repo } from '../core/Repo';
+import { RepoManager } from '../core/RepoManager';
+import { validateArgCount } from '../../utils/validation';
+import { validateUrl } from '../core/util/validation';
+import { FirebaseApp, FirebaseService } from '../../app/firebase_app';
+import { RepoInfo } from '../core/RepoInfo';
 
 /**
  * Class representing a firebase database.
- * @implements {firebase.Service}
+ * @implements {FirebaseService}
  */
-export class Database {
-  /** @type {Repo} */
-  repo_;
-  /** @type {Firebase} */
-  root_;
-  INTERNAL;
-
-  static ServerValue = {
+export class Database implements FirebaseService {
+  /** @type {Reference} */
+  private root_: Reference;
+
+  /** @type {DatabaseInternals} */
+  INTERNAL: DatabaseInternals;
+
+  app: FirebaseApp | null;
+
+  static readonly ServerValue = {
     'TIMESTAMP': {
-      '.sv' : 'timestamp'
+      '.sv': 'timestamp'
     }
-  }
+  };
 
   /**
    * The constructor should not be called by users of our public API.
-   * @param {!Repo} repo
+   * @param {!Repo} repo_
    */
-  constructor(repo) {
-    if (!(repo instanceof Repo)) {
-      fatal("Don't call new Database() directly - please use firebase.database().");
+  constructor(private repo_: Repo) {
+    if (!(repo_ instanceof Repo)) {
+      fatal('Don\'t call new Database() directly - please use firebase.database().');
     }
 
-    /** @type {Repo} */
-    this.repo_ = repo;
-
-    /** @type {Firebase} */
-    this.root_ = new Reference(repo, Path.Empty);
+    /** @type {Reference} */
+    this.root_ = new Reference(repo_, Path.Empty);
 
     this.INTERNAL = new DatabaseInternals(this);
   }
 
-  app: null
-
   /**
    * Returns a reference to the root or the path specified in opt_pathString.
-   * @param {string=} opt_pathString
-   * @return {!Firebase} Firebase reference.
+   * @param {string=} pathString
+   * @return {!Reference} Firebase reference.
    */
-  ref(opt_pathString): Reference {
+  ref(pathString?: string): Reference {
     this.checkDeleted_('ref');
     validateArgCount('database.ref', 0, 1, arguments.length);
 
-    return opt_pathString !== undefined ? this.root_.child(opt_pathString) : this.root_;
+    return pathString !== undefined ? this.root_.child(pathString) : this.root_;
   }
 
   /**
    * Returns a reference to the root or the path specified in url.
    * We throw a exception if the url is not in the same domain as the
    * current repo.
    * @param {string} url
-   * @return {!Firebase} Firebase reference.
+   * @return {!Reference} Firebase reference.
    */
-  refFromURL(url) {
+  refFromURL(url: string): Reference {
     /** @const {string} */
-    var apiName = 'database.refFromURL';
+    const apiName = 'database.refFromURL';
     this.checkDeleted_(apiName);
     validateArgCount(apiName, 1, 1, arguments.length);
-    var parsedURL = parseRepoInfo(url);
+    const parsedURL = parseRepoInfo(url);
     validateUrl(apiName, 1, parsedURL);
 
-    var repoInfo = parsedURL.repoInfo;
-    if (repoInfo.host !== this.repo_.repoInfo_.host) {
-      fatal(apiName + ": Host name does not match the current database: " +
-                         "(found " + repoInfo.host + " but expected " + this.repo_.repoInfo_.host + ")");
+    const repoInfo = parsedURL.repoInfo;
+    if (repoInfo.host !== (<RepoInfo>(<any>this.repo_).repoInfo_).host) {
+      fatal(apiName + ': Host name does not match the current database: ' +
+        '(found ' + repoInfo.host + ' but expected ' +
+        (<RepoInfo>(<any>this.repo_).repoInfo_).host + ')');
     }
 
     return this.ref(parsedURL.path.toString());
@@ -85,9 +85,9 @@ export class Database {
    * @param {string} apiName
    * @private
    */
-  checkDeleted_(apiName) {
+  private checkDeleted_(apiName: string) {
     if (this.repo_ === null) {
-      fatal("Cannot call " + apiName + " on a deleted database.");
+      fatal('Cannot call ' + apiName + ' on a deleted database.');
     }
   }
 
@@ -98,47 +98,45 @@ export class Database {
     this.repo_.interrupt();
   }
 
-  goOnline () {
+  goOnline() {
     validateArgCount('database.goOnline', 0, 0, arguments.length);
     this.checkDeleted_('goOnline');
     this.repo_.resume();
   }
-};
+}
 
 // Note: This is an un-minfied property of the Database only.
 Object.defineProperty(Database.prototype, 'app', {
   /**
    * @this {!Database}
    * @return {!firebase.app.App}
    */
-  get() {
+  get(): FirebaseApp {
     return this.repo_.app;
   }
 });
 
 Object.defineProperty(Repo.prototype, 'database', {
-  get() {
+  get(): Database {
     return this.__database || (this.__database = new Database(this));
   }
 });
 
-class DatabaseInternals {
-  database
+export class DatabaseInternals {
   /** @param {!Database} database */
-  constructor(database) {
-    this.database = database;
+  constructor(public database: Database) {
   }
 
-  /** @return {firebase.Promise<void>} */
-  delete() {
-    this.database.checkDeleted_('delete');
-    RepoManager.getInstance().deleteRepo(/** @type {!Repo} */ (this.database.repo_));
+  /** @return {Promise<void>} */
+  delete(): Promise<void> {
+    (<any>this.database).checkDeleted_('delete');
+    RepoManager.getInstance().deleteRepo(/** @type {!Repo} */ <Repo>((<any>this.database).repo_));
 
-    this.database.repo_ = null;
-    this.database.root_ = null;
+    (<any>this.database).repo_ = null;
+    (<any>this.database).root_ = null;
     this.database.INTERNAL = null;
     this.database = null;
     return PromiseImpl.resolve();
   }
-};
+}
 

src/database/api/Query.ts

@@ -143,8 +143,8 @@ export class Query {
    * @param {Object=} context
    * @return {!function(DataSnapshot, string=)}
    */
-  on(eventType: string, callback: (a: DataSnapshot, b?: string) => any,
-     cancelCallbackOrContext?: ((a: Error) => any) | Object, context?: Object): (a: DataSnapshot, b?: string) => any {
+  on(eventType: string, callback: (a: DataSnapshot, b?: string) => void,
+     cancelCallbackOrContext?: ((a: Error) => void) | Object, context?: Object): (a: DataSnapshot, b?: string) => void {
     validateArgCount('Query.on', 2, 4, arguments.length);
     validateEventType('Query.on', 1, eventType, false);
     validateCallback('Query.on', 2, callback, false);
@@ -167,7 +167,7 @@ export class Query {
    * @param {?Object} context
    * @protected
    */
-  onValueEvent(callback: (a: DataSnapshot) => any, cancelCallback: ((a: Error) => any) | null, context: Object | null) {
+  protected onValueEvent(callback: (a: DataSnapshot) => void, cancelCallback: ((a: Error) => void) | null, context: Object | null) {
     const container = new ValueEventRegistration(callback, cancelCallback || null, context || null);
     this.repo.addEventCallbackForQuery(this, container);
   }
@@ -176,9 +176,10 @@ export class Query {
    * @param {!Object.<string, !function(!DataSnapshot, ?string)>} callbacks
    * @param {?function(Error)} cancelCallback
    * @param {?Object} context
+   * @protected
    */
-  onChildEvent(callbacks: { [k: string]: (a: DataSnapshot, b: string | null) => any },
-               cancelCallback: ((a: Error) => any) | null, context: Object | null) {
+  protected onChildEvent(callbacks: { [k: string]: (a: DataSnapshot, b: string | null) => void },
+               cancelCallback: ((a: Error) => void) | null, context: Object | null) {
     const container = new ChildEventRegistration(callbacks, cancelCallback, context);
     this.repo.addEventCallbackForQuery(this, container);
   }
@@ -188,7 +189,7 @@ export class Query {
    * @param {(function(!DataSnapshot, ?string=))=} callback
    * @param {Object=} context
    */
-  off(eventType?: string, callback?: (a: DataSnapshot, b?: string | null) => any, context?: Object) {
+  off(eventType?: string, callback?: (a: DataSnapshot, b?: string | null) => void, context?: Object) {
     validateArgCount('Query.off', 0, 3, arguments.length);
     validateEventType('Query.off', 1, eventType, true);
     validateCallback('Query.off', 2, callback, true);
@@ -217,7 +218,7 @@ export class Query {
    * @param context
    * @return {!firebase.Promise}
    */
-  once(eventType: string, userCallback: (a: DataSnapshot, b?: string) => any,
+  once(eventType: string, userCallback: (a: DataSnapshot, b?: string) => void,
        cancelOrContext?, context?: Object) {
     validateArgCount('Query.once', 1, 4, arguments.length);
     validateEventType('Query.once', 1, eventType, false);
@@ -487,8 +488,8 @@ export class Query {
    * @return {{cancel: ?function(Error), context: ?Object}}
    * @private
    */
-  private static getCancelAndContextArgs_(fnName: string, cancelOrContext?: ((a: Error) => any) | Object,
-                                   context?: Object): { cancel: ((a: Error) => any) | null, context: Object | null } {
+  private static getCancelAndContextArgs_(fnName: string, cancelOrContext?: ((a: Error) => void) | Object,
+                                   context?: Object): { cancel: ((a: Error) => void) | null, context: Object | null } {
     const ret = {cancel: null, context: null};
     if (cancelOrContext && context) {
       ret.cancel = /** @type {function(Error)} */ (cancelOrContext);

src/database/api/Reference.ts

@@ -105,7 +105,7 @@ export class Reference extends Query {
    * @param {function(?Error)=} onComplete
    * @return {!Promise}
    */
-  set(newVal: any, onComplete?: (a: Error | null) => any): Promise<any> {
+  set(newVal: any, onComplete?: (a: Error | null) => void): Promise<any> {
     validateArgCount('Reference.set', 1, 2, arguments.length);
     validateWritablePath('Reference.set', this.path);
     validateFirebaseDataArg('Reference.set', 1, newVal, this.path, false);
@@ -121,7 +121,7 @@ export class Reference extends Query {
    * @param {function(?Error)=} onComplete
    * @return {!Promise}
    */
-  update(objectToMerge: Object, onComplete?: (a: Error | null) => any): Promise<any> {
+  update(objectToMerge: Object, onComplete?: (a: Error | null) => void): Promise<any> {
     validateArgCount('Reference.update', 1, 2, arguments.length);
     validateWritablePath('Reference.update', this.path);
 
@@ -151,7 +151,7 @@ export class Reference extends Query {
    * @return {!Promise}
    */
   setWithPriority(newVal: any, newPriority: string | number | null,
-                  onComplete?: (a: Error | null) => any): Promise<any> {
+                  onComplete?: (a: Error | null) => void): Promise<any> {
     validateArgCount('Reference.setWithPriority', 2, 3, arguments.length);
     validateWritablePath('Reference.setWithPriority', this.path);
     validateFirebaseDataArg('Reference.setWithPriority', 1, newVal, this.path, false);
@@ -170,7 +170,7 @@ export class Reference extends Query {
    * @param {function(?Error)=} onComplete
    * @return {!Promise}
    */
-  remove(onComplete?: (a: Error | null) => any): Promise<any> {
+  remove(onComplete?: (a: Error | null) => void): Promise<any> {
     validateArgCount('Reference.remove', 0, 1, arguments.length);
     validateWritablePath('Reference.remove', this.path);
     validateCallback('Reference.remove', 1, onComplete, true);
@@ -185,7 +185,7 @@ export class Reference extends Query {
    * @return {!Promise}
    */
   transaction(transactionUpdate: (a: any) => any,
-              onComplete?: (a: Error | null, b: boolean, c: DataSnapshot | null) => any,
+              onComplete?: (a: Error | null, b: boolean, c: DataSnapshot | null) => void,
               applyLocally?: boolean): Promise<any> {
     validateArgCount('Reference.transaction', 1, 3, arguments.length);
     validateWritablePath('Reference.transaction', this.path);
@@ -226,7 +226,7 @@ export class Reference extends Query {
    * @param {function(?Error)=} onComplete
    * @return {!Promise}
    */
-  setPriority(priority: string | number | null, onComplete?: (a: Error | null) => any): Promise<any> {
+  setPriority(priority: string | number | null, onComplete?: (a: Error | null) => void): Promise<any> {
     validateArgCount('Reference.setPriority', 1, 2, arguments.length);
     validateWritablePath('Reference.setPriority', this.path);
     validatePriority('Reference.setPriority', 1, priority, false);
@@ -242,7 +242,7 @@ export class Reference extends Query {
    * @param {function(?Error)=} onComplete
    * @return {!Reference}
    */
-  push(value?: any, onComplete?: (a: Error | null) => any): Reference {
+  push(value?: any, onComplete?: (a: Error | null) => void): Reference {
     validateArgCount('Reference.push', 0, 2, arguments.length);
     validateWritablePath('Reference.push', this.path);
     validateFirebaseDataArg('Reference.push', 1, value, this.path, true);

src/database/api/TransactionResult.ts

@@ -1,19 +1,13 @@
+import { DataSnapshot } from './DataSnapshot';
+
 export class TransactionResult {
   /**
    * A type for the resolve value of Firebase.transaction.
    * @constructor
    * @dict
    * @param {boolean} committed
-   * @param {fb.api.DataSnapshot} snapshot
+   * @param {DataSnapshot} snapshot
    */
-  constructor(committed, snapshot) {
-    /**
-    * @type {boolean}
-    */
-    this['committed'] = committed;
-    /**
-    * @type {fb.api.DataSnapshot}
-    */
-    this['snapshot'] = snapshot;
+  constructor(public committed: boolean, public snapshot: DataSnapshot) {
   }
 }

src/database/api/internal.ts

@@ -1,5 +1,6 @@
 import { WebSocketConnection } from "../realtime/WebSocketConnection";
 import { BrowserPollConnection } from "../realtime/BrowserPollConnection";
+import { Reference } from './Reference';
 
 /**
  * INTERNAL methods for internal-use only (tests, etc.).
@@ -19,26 +20,26 @@ export const forceWebSockets = function() {
 };
 
 /* Used by App Manager */
-export const isWebSocketsAvailable = function() {
+export const isWebSocketsAvailable = function(): boolean {
   return WebSocketConnection['isAvailable']();
 };
 
-export const setSecurityDebugCallback = function(ref, callback) {
-  ref.repo.persistentConnection_.securityDebugCallback_ = callback;
+export const setSecurityDebugCallback = function(ref: Reference, callback) {
+  (ref.repo.persistentConnection_ as any).securityDebugCallback_ = callback;
 };
 
-export const stats = function(ref, showDelta) {
+export const stats = function(ref: Reference, showDelta?: boolean) {
   ref.repo.stats(showDelta);
 };
 
-export const statsIncrementCounter = function(ref, metric) {
+export const statsIncrementCounter = function(ref: Reference, metric: string) {
   ref.repo.statsIncrementCounter(metric);
 };
 
-export const dataUpdateCount = function(ref) {
+export const dataUpdateCount = function(ref: Reference): number {
   return ref.repo.dataUpdateCount;
 };
 
-export const interceptServerData = function(ref, callback) {
+export const interceptServerData = function(ref: Reference, callback: ((a: string, b: any) => void) | null) {
   return ref.repo.interceptServerData_(callback);
 };