Add a toJSON() method to database.DeltaSnapshot, to unbreak our build (#118)

Add a toJSON() method to database.DeltaSnapshot, to unbreak our build after the release of firebase-admin 4.1.2.

Author: Robert-Jan Huijsman

spec/providers/database.spec.ts

@@ -23,8 +23,8 @@
 import * as database from '../../src/providers/database';
 import { expect as expect } from 'chai';
 import { fakeConfig } from '../support/helpers';
-import {apps as appsNamespace} from '../../src/apps';
-import {config} from '../../src/index';
+import { apps as appsNamespace } from '../../src/apps';
+import { config } from '../../src/index';
 
 describe('DatabaseBuilder', () => {
 
@@ -53,13 +53,13 @@ describe('DatabaseBuilder', () => {
 
     it('should return a handler that emits events with a proper DeltaSnapshot', () => {
       let handler = database.ref('/users/{id}').onWrite(event => {
-        expect(event.data.val()).to.deep.equal({foo: 'bar'});
+        expect(event.data.val()).to.deep.equal({ foo: 'bar' });
       });
 
       return handler({
         data: {
           data: null,
-          delta: {foo: 'bar'},
+          delta: { foo: 'bar' },
         },
         resource: 'projects/_/instances/subdomains/refs/users',
       } as any);
@@ -90,87 +90,87 @@ describe('DeltaSnapshot', () => {
 
   let populate = (old: any, change: any) => {
     subject = new database.DeltaSnapshot(
-        apps.admin,
-        apps.admin,
-        old,
-        change,
-        database.resourceToPath('projects/_/instances/mySubdomain/refs/foo')
-      );
+      apps.admin,
+      apps.admin,
+      old,
+      change,
+      database.resourceToPath('projects/_/instances/mySubdomain/refs/foo')
+    );
   };
 
   describe('#val(): any', () => {
     it('should return child values based on the child path', () => {
-      populate({a: {b: 'c'}}, {a: {d: 'e'}});
-      expect(subject.child('a').val()).to.deep.equal({b: 'c', d: 'e'});
+      populate({ a: { b: 'c' } }, { a: { d: 'e' } });
+      expect(subject.child('a').val()).to.deep.equal({ b: 'c', d: 'e' });
     });
 
     it('should return null for children past a leaf', () => {
-      populate({a: 23}, {b: 33});
+      populate({ a: 23 }, { b: 33 });
       expect(subject.child('a/b').val()).to.be.null;
       expect(subject.child('b/c').val()).to.be.null;
     });
 
     it('should return a leaf value', () => {
       populate(null, 23);
       expect(subject.val()).to.eq(23);
-      populate({a: 23}, {b: 23, a: null});
+      populate({ a: 23 }, { b: 23, a: null });
       expect(subject.child('b').val()).to.eq(23);
     });
 
-    it ('should coerce object into array if all keys are integers', () => {
-      populate(null, {0: 'a', 1: 'b', 2: {c: 'd'}});
-      expect(subject.val()).to.deep.equal(['a', 'b', {c: 'd'}]);
-      populate(null, {0: 'a', 2: 'b', 3: {c: 'd'}});
-      expect(subject.val()).to.deep.equal(['a', ,'b', {c: 'd'}]);
-      populate(null, {'foo': {0: 'a', 1: 'b'}});
-      expect(subject.val()).to.deep.equal({foo: ['a', 'b']});
+    it('should coerce object into array if all keys are integers', () => {
+      populate(null, { 0: 'a', 1: 'b', 2: { c: 'd' } });
+      expect(subject.val()).to.deep.equal(['a', 'b', { c: 'd' }]);
+      populate(null, { 0: 'a', 2: 'b', 3: { c: 'd' } });
+      expect(subject.val()).to.deep.equal(['a', , 'b', { c: 'd' }]);
+      populate(null, { 'foo': { 0: 'a', 1: 'b' } });
+      expect(subject.val()).to.deep.equal({ foo: ['a', 'b'] });
     });
 
     // Regression test: zero-values (including children) were accidentally forwarded as 'null'.
-    it ('should deal with zero-values appropriately', () => {
+    it('should deal with zero-values appropriately', () => {
       populate(null, 0);
       expect(subject.val()).to.equal(0);
-      populate(null, {myKey: 0});
-      expect(subject.val()).to.deep.equal({myKey: 0});
+      populate(null, { myKey: 0 });
+      expect(subject.val()).to.deep.equal({ myKey: 0 });
 
       // Null values are still reported as null.
-      populate({myKey: 'foo', myOtherKey: 'bar'}, {myKey: null});
-      expect(subject.val()).to.deep.equal({myOtherKey: 'bar'});
+      populate({ myKey: 'foo', myOtherKey: 'bar' }, { myKey: null });
+      expect(subject.val()).to.deep.equal({ myOtherKey: 'bar' });
     });
   });
 
   describe('#child(): DeltaSnapshot', () => {
     it('should work with multiple calls', () => {
-      populate(null, {a: {b: {c: 'd'}}});
+      populate(null, { a: { b: { c: 'd' } } });
       expect(subject.child('a').child('b/c').val()).to.equal('d');
     });
   });
 
   describe('#exists(): boolean', () => {
     it('should be true for an object value', () => {
-      populate(null, {a: {b: 'c'}});
+      populate(null, { a: { b: 'c' } });
       expect(subject.child('a').exists()).to.be.true;
     });
 
     it('should be true for a leaf value', () => {
-      populate(null, {a: {b: 'c'}});
+      populate(null, { a: { b: 'c' } });
       expect(subject.child('a/b').exists()).to.be.true;
     });
 
     it('should be false for a non-existent value', () => {
-      populate(null, {a: {b: 'c'}});
+      populate(null, { a: { b: 'c' } });
       expect(subject.child('d').exists()).to.be.false;
     });
 
     it('should be false for a value pathed beyond a leaf', () => {
-      populate(null, {a: {b: 'c'}});
+      populate(null, { a: { b: 'c' } });
       expect(subject.child('a/b/c').exists()).to.be.false;
     });
   });
 
   describe('#previous: DeltaSnapshot', () => {
     it('should cause val() to return old data only', () => {
-      populate({a: 'b'}, {a: 'c', d: 'c'});
+      populate({ a: 'b' }, { a: 'c', d: 'c' });
       expect(subject.previous.child('a').val()).to.equal('b');
     });
 
@@ -182,7 +182,7 @@ describe('DeltaSnapshot', () => {
 
   describe('#current: DeltaSnapshot', () => {
     it('should cause a previous snapshot to return new data', () => {
-      populate({a: 'b'}, {a: 'c', d: 'c'});
+      populate({ a: 'b' }, { a: 'c', d: 'c' });
       expect(subject.previous.child('a').current.val()).to.equal('c');
     });
 
@@ -194,7 +194,7 @@ describe('DeltaSnapshot', () => {
 
   describe('#changed(): boolean', () => {
     it('should be true only when the current value has changed', () => {
-      populate({a: {b: 'c'}}, {a: {d: 'e'}});
+      populate({ a: { b: 'c' } }, { a: { d: 'e' } });
       expect(subject.child('a').changed()).to.be.true;
       expect(subject.child('a/b').changed()).to.be.false;
       expect(subject.child('a/d').changed()).to.be.true;
@@ -210,7 +210,7 @@ describe('DeltaSnapshot', () => {
 
   describe('#forEach(childAction: Function)', () => {
     it('should iterate through child snapshots', () => {
-      populate({a: 'b'}, {c: 'd'});
+      populate({ a: 'b' }, { c: 'd' });
       let out = '';
       subject.forEach(snap => {
         out += snap.val();
@@ -233,7 +233,7 @@ describe('DeltaSnapshot', () => {
 
   describe('#numChildren()', () => {
     it('should be key count for objects', () => {
-      populate(null, {a: 'b', c: 'd'});
+      populate(null, { a: 'b', c: 'd' });
       expect(subject.numChildren()).to.eq(2);
     });
 
@@ -245,13 +245,13 @@ describe('DeltaSnapshot', () => {
 
   describe('#hasChild(childPath): boolean', () => {
     it('should return true for a child or deep child', () => {
-      populate(null, {a: {b: 'c'}, d: 23});
+      populate(null, { a: { b: 'c' }, d: 23 });
       expect(subject.hasChild('a/b')).to.be.true;
       expect(subject.hasChild('d')).to.be.true;
     });
 
     it('should return false if a child is missing', () => {
-      populate(null, {a: 'b'});
+      populate(null, { a: 'b' });
       expect(subject.hasChild('c')).to.be.false;
       expect(subject.hasChild('a/b')).to.be.false;
     });
@@ -287,4 +287,16 @@ describe('DeltaSnapshot', () => {
       expect(subject.child('foo/bar').key).to.equal('bar');
     });
   });
+
+  describe('#toJSON(): Object', () => {
+    it('should return the current value', () => {
+      populate(null, { a: 'b' });
+      expect(subject.toJSON()).to.deep.equal(subject.val());
+      expect(subject.previous.toJSON()).to.deep.equal(subject.previous.val());
+    });
+    it('should be stringifyable', () => {
+      populate(null, { a: 'b' });
+      expect(JSON.stringify(subject)).to.deep.equal('{"a":"b"}');
+    });
+  });
 });

src/providers/database.ts

@@ -22,10 +22,10 @@
 
 import * as _ from 'lodash';
 import { apps } from '../apps';
-import {Event, CloudFunction, makeCloudFunction} from '../cloud-functions';
-import {normalizePath, applyChange, pathParts, valAt, joinPath} from '../utils';
+import { Event, CloudFunction, makeCloudFunction } from '../cloud-functions';
+import { normalizePath, applyChange, pathParts, valAt, joinPath } from '../utils';
 import * as firebase from 'firebase-admin';
-import {config} from '../index';
+import { config } from '../index';
 
 /** @internal */
 export const provider = 'google.firebase.database';
@@ -70,11 +70,11 @@ export function ref(path: string): RefBuilder {
 /** Builder used to create Cloud Functions for Firebase Realtime Database References. */
 export class RefBuilder {
   /** @internal */
-  constructor(private apps: apps.Apps, private resource) {}
+  constructor(private apps: apps.Apps, private resource) { }
 
   /** Respond to any write that affects a ref. */
   onWrite(handler: (event: Event<DeltaSnapshot>) => PromiseLike<any> | any): CloudFunction<DeltaSnapshot> {
-    const dataConstructor  = (raw: Event<any>) => {
+    const dataConstructor = (raw: Event<any>) => {
       if (raw.data instanceof DeltaSnapshot) {
         return raw.data;
       }
@@ -111,7 +111,7 @@ export function resourceToPath(resource) {
     throw new Error(`Unexpected resource string for Firebase Realtime Database event: ${resource}. ` +
       'Expected string in the format of "projects/_/instances/{firebaseioSubdomain}/refs/{ref=**}"');
   }
-  let [, project, /* instance */ , path] = match;
+  let [, project, /* instance */, path] = match;
   if (project !== '_') {
     throw new Error(`Expect project to be '_' in a Firebase Realtime Database event`);
   }
@@ -224,6 +224,13 @@ export class DeltaSnapshot implements firebase.database.DataSnapshot {
     return _.isPlainObject(val) ? Object.keys(val).length : 0;
   }
 
+  /** Prints the value of the snapshot; use '.previous' and '.current' to explicitly see
+   *  the previous and current values.
+   */
+  toJSON(): Object {
+    return this.val();
+  }
+
   /* Recursive function to check if keys are numeric & convert node object to array if they are */
   private _checkAndConvertToArray(node): any {
     if (node === null || typeof node === 'undefined') {