refactor(database): add typescript implementation

Author: jshcrowthe

src/database.ts

@@ -0,0 +1,60 @@
+/**
+* Copyright 2017 Google Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import firebase from './app';
+import { FirebaseApp, FirebaseNamespace } from "./app/firebase_app";
+import { Database } from "./database/api/Database";
+import { Query } from "./database/api/Query";
+import { Reference } from "./database/api/Reference";
+import { enableLogging } from "./database/core/util/util";
+import { RepoManager } from "./database/core/RepoManager";
+import * as INTERNAL from './database/api/internal';
+import * as TEST_ACCESS from './database/api/test_access';
+
+export function registerDatabase(instance) {
+  // Register the Database Service with the 'firebase' namespace.
+  instance.INTERNAL.registerService(
+    'database',
+    app => RepoManager.getInstance().databaseFromApp(app),
+    // firebase.database namespace properties
+    {
+      Reference,
+      Query,
+      Database,
+      enableLogging,
+      INTERNAL,
+      ServerValue: Database.ServerValue,
+      TEST_ACCESS
+    }
+  );
+}
+
+/**
+ * Extensions to the FirebaseApp and FirebaseNamespaces interfaces
+ */
+declare module './app/firebase_app' {
+  interface FirebaseApp {
+    database?(): Database
+  }
+}
+
+declare module './app/firebase_app' {
+  interface FirebaseNamespace {
+    database?(app: FirebaseApp): Database
+  }
+}
+
+registerDatabase(firebase);

src/database/api/DataSnapshot.ts

@@ -0,0 +1,187 @@
+import { validateArgCount, validateCallback } from "../../utils/validation";
+import { validatePathString } from "../core/util/validation";
+import { Path } from "../core/util/Path";
+import { exportPropGetter } from "../core/util/util";
+import { PRIORITY_INDEX } from "../core/snap/indexes/PriorityIndex";
+
+/**
+ * Class representing a firebase data snapshot.  It wraps a SnapshotNode and
+ * surfaces the public methods (val, forEach, etc.) we want to expose.
+ *
+ * @constructor
+ * @param {!fb.core.snap.Node} node A SnapshotNode to wrap.
+ * @param {!Firebase} ref The ref of the location this snapshot came from.
+ * @param {!fb.core.snap.Index} index The iteration order for this snapshot
+ */
+export const DataSnapshot = function(node, ref, index) {
+  /**
+   * @private
+   * @const
+   * @type {!fb.core.snap.Node}
+   */
+  this.node_ = node;
+
+  /**
+   * @private
+   * @type {!Firebase}
+   * @const
+   */
+  this.query_ = ref;
+
+  /**
+   * @const
+   * @type {!fb.core.snap.Index}
+   * @private
+   */
+  this.index_ = index;
+};
+
+
+/**
+ * Retrieves the snapshot contents as JSON.  Returns null if the snapshot is
+ * empty.
+ *
+ * @return {*} JSON representation of the DataSnapshot contents, or null if empty.
+ */
+DataSnapshot.prototype.val = function() {
+  validateArgCount('Firebase.DataSnapshot.val', 0, 0, arguments.length);
+  return this.node_.val();
+};
+
+/**
+ * Returns the snapshot contents as JSON, including priorities of node.  Suitable for exporting
+ * the entire node contents.
+ * @return {*} JSON representation of the DataSnapshot contents, or null if empty.
+ */
+DataSnapshot.prototype.exportVal = function() {
+  validateArgCount('Firebase.DataSnapshot.exportVal', 0, 0, arguments.length);
+  return this.node_.val(true);
+};
+
+// Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
+// for end-users
+DataSnapshot.prototype.toJSON = function() {
+  // Optional spacer argument is unnecessary because we're depending on recursion rather than stringifying the content
+  validateArgCount('Firebase.DataSnapshot.toJSON', 0, 1, arguments.length);
+  return this.exportVal();
+};
+
+/**
+ * Returns whether the snapshot contains a non-null value.
+ *
+ * @return {boolean} Whether the snapshot contains a non-null value, or is empty.
+ */
+DataSnapshot.prototype.exists = function() {
+  validateArgCount('Firebase.DataSnapshot.exists', 0, 0, arguments.length);
+  return !this.node_.isEmpty();
+};
+
+/**
+ * Returns a DataSnapshot of the specified child node's contents.
+ *
+ * @param {!string} childPathString Path to a child.
+ * @return {!DataSnapshot} DataSnapshot for child node.
+ */
+DataSnapshot.prototype.child = function(childPathString) {
+  validateArgCount('Firebase.DataSnapshot.child', 0, 1, arguments.length);
+  // Ensure the childPath is a string (can be a number)
+  childPathString = String(childPathString);
+  validatePathString('Firebase.DataSnapshot.child', 1, childPathString, false);
+
+  var childPath = new Path(childPathString);
+  var childRef = this.query_.child(childPath);
+  return new DataSnapshot(this.node_.getChild(childPath), childRef, PRIORITY_INDEX);
+};
+
+/**
+ * Returns whether the snapshot contains a child at the specified path.
+ *
+ * @param {!string} childPathString Path to a child.
+ * @return {boolean} Whether the child exists.
+ */
+DataSnapshot.prototype.hasChild = function(childPathString) {
+  validateArgCount('Firebase.DataSnapshot.hasChild', 1, 1, arguments.length);
+  validatePathString('Firebase.DataSnapshot.hasChild', 1, childPathString, false);
+
+  var childPath = new Path(childPathString);
+  return !this.node_.getChild(childPath).isEmpty();
+};
+
+/**
+ * Returns the priority of the object, or null if no priority was set.
+ *
+ * @return {string|number|null} The priority.
+ */
+DataSnapshot.prototype.getPriority = function() {
+  validateArgCount('Firebase.DataSnapshot.getPriority', 0, 0, arguments.length);
+
+  // typecast here because we never return deferred values or internal priorities (MAX_PRIORITY)
+  return /**@type {string|number|null} */ (this.node_.getPriority().val());
+};
+
+/**
+ * Iterates through child nodes and calls the specified action for each one.
+ *
+ * @param {function(!DataSnapshot)} action Callback function to be called
+ * for each child.
+ * @return {boolean} True if forEach was canceled by action returning true for
+ * one of the child nodes.
+ */
+DataSnapshot.prototype.forEach = function(action) {
+  validateArgCount('Firebase.DataSnapshot.forEach', 1, 1, arguments.length);
+  validateCallback('Firebase.DataSnapshot.forEach', 1, action, false);
+
+  if (this.node_.isLeafNode())
+    return false;
+
+  var childrenNode = /** @type {!fb.core.snap.ChildrenNode} */ (this.node_);
+  var self = this;
+  // Sanitize the return value to a boolean. ChildrenNode.forEachChild has a weird return type...
+  return !!childrenNode.forEachChild(this.index_, function(key, node) {
+    return action(new DataSnapshot(node, self.query_.child(key), PRIORITY_INDEX));
+  });
+};
+
+/**
+ * Returns whether this DataSnapshot has children.
+ * @return {boolean} True if the DataSnapshot contains 1 or more child nodes.
+ */
+DataSnapshot.prototype.hasChildren = function() {
+  validateArgCount('Firebase.DataSnapshot.hasChildren', 0, 0, arguments.length);
+
+  if (this.node_.isLeafNode())
+    return false;
+  else
+    return !this.node_.isEmpty();
+};
+
+/**
+ * @return {?string} The key of the location this snapshot's data came from.
+ */
+DataSnapshot.prototype.getKey = function() {
+  validateArgCount('Firebase.DataSnapshot.key', 0, 0, arguments.length);
+
+  return this.query_.getKey();
+};
+exportPropGetter(DataSnapshot.prototype, 'key', DataSnapshot.prototype.getKey);
+
+
+/**
+ * Returns the number of children for this DataSnapshot.
+ * @return {number} The number of children that this DataSnapshot contains.
+ */
+DataSnapshot.prototype.numChildren = function() {
+  validateArgCount('Firebase.DataSnapshot.numChildren', 0, 0, arguments.length);
+
+  return this.node_.numChildren();
+};
+
+/**
+ * @return {Firebase} The Firebase reference for the location this snapshot's data came from.
+ */
+DataSnapshot.prototype.getRef = function() {
+  validateArgCount('Firebase.DataSnapshot.ref', 0, 0, arguments.length);
+
+  return this.query_;
+};
+exportPropGetter(DataSnapshot.prototype, 'ref', DataSnapshot.prototype.getRef);

src/database/api/Database.ts

@@ -0,0 +1,144 @@
+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";
+
+/**
+ * Class representing a firebase database.
+ * @implements {firebase.Service}
+ */
+export class Database {
+  /** @type {Repo} */
+  repo_;
+  /** @type {Firebase} */
+  root_;
+  INTERNAL;
+
+  static ServerValue = {
+    'TIMESTAMP': {
+      '.sv' : 'timestamp'
+    }
+  }
+
+  /**
+   * The constructor should not be called by users of our public API.
+   * @param {!Repo} repo
+   */
+  constructor(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);
+
+    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.
+   */
+  ref(opt_pathString): Reference {
+    this.checkDeleted_('ref');
+    validateArgCount('database.ref', 0, 1, arguments.length);
+
+    return opt_pathString !== undefined ? this.root_.child(opt_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.
+   */
+  refFromURL(url) {
+    /** @const {string} */
+    var apiName = 'database.refFromURL';
+    this.checkDeleted_(apiName);
+    validateArgCount(apiName, 1, 1, arguments.length);
+    var 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 + ")");
+    }
+
+    return this.ref(parsedURL.path.toString());
+  }
+
+  /**
+   * @param {string} apiName
+   * @private
+   */
+  checkDeleted_(apiName) {
+    if (this.repo_ === null) {
+      fatal("Cannot call " + apiName + " on a deleted database.");
+    }
+  }
+
+  // Make individual repo go offline.
+  goOffline() {
+    validateArgCount('database.goOffline', 0, 0, arguments.length);
+    this.checkDeleted_('goOffline');
+    this.repo_.interrupt();
+  }
+
+  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() {
+    return this.repo_.app;
+  }
+});
+
+Object.defineProperty(Repo.prototype, 'database', {
+  get() {
+    return this.__database || (this.__database = new Database(this));
+  }
+});
+
+class DatabaseInternals {
+  database
+  /** @param {!Database} database */
+  constructor(database) {
+    this.database = database;
+  }
+
+  /** @return {firebase.Promise<void>} */
+  delete() {
+    this.database.checkDeleted_('delete');
+    RepoManager.getInstance().deleteRepo(/** @type {!Repo} */ (this.database.repo_));
+
+    this.database.repo_ = null;
+    this.database.root_ = null;
+    this.database.INTERNAL = null;
+    this.database = null;
+    return PromiseImpl.resolve();
+  }
+};
+