refactor(database): Several classes and utility methods

Author: jsayol

src/database/api/Database.ts

@@ -1,56 +1,55 @@
-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.
+   * @return {!Reference} Firebase reference.
    */
-  ref(opt_pathString): Reference {
+  ref(opt_pathString?: string): Reference {
     this.checkDeleted_('ref');
     validateArgCount('database.ref', 0, 1, arguments.length);
 
@@ -62,20 +61,21 @@ export class Database {
    * 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/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) => any) | null) {
   return ref.repo.interceptServerData_(callback);
 };

src/database/api/test_access.ts

@@ -2,22 +2,23 @@ import { RepoInfo } from "../core/RepoInfo";
 import { PersistentConnection } from "../core/PersistentConnection";
 import { RepoManager } from "../core/RepoManager";
 import { Connection } from "../realtime/Connection";
+import { Query } from './Query';
 
 export const DataConnection = PersistentConnection;
 
 /**
  * @param {!string} pathString
  * @param {function(*)} onComplete
  */
-(PersistentConnection.prototype as any).simpleListen = function(pathString, onComplete) {
+(PersistentConnection.prototype as any).simpleListen = function(pathString: string, onComplete: (a: any) => any) {
   this.sendRequest('q', {'p': pathString}, onComplete);
 };
 
 /**
  * @param {*} data
  * @param {function(*)} onEcho
  */
-(PersistentConnection.prototype as any).echo = function(data, onEcho) {
+(PersistentConnection.prototype as any).echo = function(data: any, onEcho: (a: any) => any) {
   this.sendRequest('echo', {'d': data}, onEcho);
 };
 
@@ -28,8 +29,8 @@ export const RealTimeConnection = Connection;
  * @param {function(): string} newHash
  * @return {function()}
  */
-export const hijackHash = function(newHash) {
-  var oldPut = PersistentConnection.prototype.put;
+export const hijackHash = function(newHash: () => string) {
+  const oldPut = PersistentConnection.prototype.put;
   PersistentConnection.prototype.put = function(pathString, data, opt_onComplete, opt_hash) {
     if (opt_hash !== undefined) {
       opt_hash = newHash();
@@ -42,31 +43,31 @@ export const hijackHash = function(newHash) {
 };
 
 /**
- * @type {function(new:fb.core.RepoInfo, !string, boolean, !string, boolean): undefined}
+ * @type {function(new:RepoInfo, !string, boolean, !string, boolean): undefined}
  */
 export const ConnectionTarget = RepoInfo;
 
 /**
- * @param {!fb.api.Query} query
+ * @param {!Query} query
  * @return {!string}
  */
-export const queryIdentifier = function(query) {
+export const queryIdentifier = function(query: Query) {
   return query.queryIdentifier();
 };
 
 /**
- * @param {!fb.api.Query} firebaseRef
+ * @param {!Query} firebaseRef
  * @return {!Object}
  */
-export const listens = function(firebaseRef) {
-  return firebaseRef.repo.persistentConnection_.listens_;
+export const listens = function(firebaseRef: Query) {
+  return (firebaseRef.repo.persistentConnection_ as any).listens_;
 };
 
 /**
  * Forces the RepoManager to create Repos that use ReadonlyRestClient instead of PersistentConnection.
  *
  * @param {boolean} forceRestClient
  */
-export const forceRestClient = function(forceRestClient) {
+export const forceRestClient = function(forceRestClient: boolean) {
   RepoManager.getInstance().forceRestClient(forceRestClient);
 };