Improvement for DataSnapshot paths (#10, #26)

package.json

@@ -37,12 +37,12 @@
     "@types/chai": "^4.1.2",
     "@types/mocha": "^5.0.0",
     "chai": "^4.1.2",
-    "firebase-admin": "~6.1.0",
+    "firebase-admin": "^6.2.0",
     "firebase-functions": "^2.1.0",
     "mocha": "^5.0.5",
     "sinon": "^4.4.9",
     "tslint": "^5.8.0",
-    "typescript": "^2.4.1"
+    "typescript": "^2.9.2"
   },
   "peerDependencies": {
     "firebase-functions": ">1.0.1",

spec/main.spec.ts

@@ -24,7 +24,16 @@ import { expect } from 'chai';
 import * as functions from 'firebase-functions';
 import { set } from 'lodash';
 
-import { mockConfig, makeChange, _makeResourceName, wrap } from '../src/main';
+import {
+    mockConfig,
+    makeChange,
+    _compiledWildcardPath,
+    wrap,
+    _isValidWildcardMatch,
+    _extractParamsFromPath,
+} from '../src/main';
+import { makeDataSnapshot } from '../src/providers/database';
+import { FirebaseFunctionsTest } from '../src/lifecycle';
 
 describe('main', () => {
   describe('#wrap', () => {
@@ -54,7 +63,7 @@ describe('main', () => {
       expect(typeof context.eventId).to.equal('string');
       expect(context.resource.service).to.equal('service');
       expect(/ref\/wildcard[1-9]\/nested\/anotherWildcard[1-9]/
-        .test(context.resource.name)).to.be.true;
+      .test(context.resource.name)).to.be.true;
       expect(context.eventType).to.equal('event');
       expect(Date.parse(context.timestamp)).to.be.greaterThan(0);
       expect(context.params).to.deep.equal({});
@@ -106,11 +115,124 @@ describe('main', () => {
       expect(context.params).to.deep.equal(params);
       expect(context.resource.name).to.equal('ref/a/nested/b');
     });
+
+    it('should throw when snapshot path includes wildcards', () => {
+      const fft = new FirebaseFunctionsTest();
+      fft.init();
+
+      const snap = makeDataSnapshot(
+          'hello world',
+          '/ref/{wildcard}/nested/{anotherWildcard}',
+      );
+      const params = {
+          wildcard: 'at',
+          anotherWildcard: 'bat',
+      };
+      const wrapped = wrap(constructCF('google.firebase.database.ref.write'));
+      expect(() => wrapped(snap, { params })).to.throw();
+    });
+
+    it('should set auto-fill params based on DataSnapshot path', () => {
+      const fft = new FirebaseFunctionsTest();
+      fft.init();
+
+      const snap = makeDataSnapshot(
+        'hello world',
+        '/ref/cat/nested/that',
+      );
+
+      const wrapped = wrap(constructCF('google.firebase.database.ref.write'));
+      const result = wrapped(snap, {});
+
+      expect(result.data._path).to.equal('ref/cat/nested/that');
+      expect(result.data.key).to.equal('that');
+      expect(result.context.params.wildcard).to.equal('cat');
+      expect(result.context.resource.name).to.equal('ref/cat/nested/that');
+    });
+
+    it('should error when DataSnapshot path does not match trigger template', () => {
+      const fft = new FirebaseFunctionsTest();
+      fft.init();
+
+      const snap = makeDataSnapshot(
+          'hello world',
+          '/different/at/nested/bat',
+      );
+      const wrapped = wrap(constructCF('google.firebase.database.ref.write'));
+      expect(() => wrapped(snap, { params })).to.throw();
+    });
+  });
+
+  describe('#_extractParamsFromPath', () => {
+    it('should match a path which fits a wildcard template', () => {
+      const params = _extractParamsFromPath(
+        'companies/{company}/users/{user}',
+                '/companies/firebase/users/abe');
+      expect(params).to.deep.equal({company: 'firebase', user: 'abe'});
+    });
+
+    it('should not match unfilled wildcards', () => {
+      const params = _extractParamsFromPath(
+          'companies/{company}/users/{user}',
+          'companies/{still_wild}/users/abe');
+      expect(params).to.deep.equal({user: 'abe'});
+    });
+
+    it('should not match a path which is too long', () => {
+      const params = _extractParamsFromPath(
+          'companies/{company}/users/{user}',
+          'companies/firebase/users/abe/boots');
+      expect(params).to.deep.equal({});
+    });
+
+    it('should not match a path which is too short', () => {
+      const params = _extractParamsFromPath(
+        'companies/{company}/users/{user}',
+        'companies/firebase/users/');
+      expect(params).to.deep.equal({});
+    });
+
+    it('should not match a path which has different chunks', () => {
+      const params = _extractParamsFromPath(
+        'locations/{company}/users/{user}',
+        'companies/firebase/users/{user}');
+      expect(params).to.deep.equal({});
+    });
+  });
+
+  describe('#_isValidWildcardMatch', () => {
+      it('should match a path which fits a wildcard template', () => {
+          const valid = _isValidWildcardMatch(
+              'companies/{company}/users/{user}',
+              '/companies/firebase/users/abe');
+          expect(valid).to.equal(true);
+      });
+
+      it('should not match a path which is too long', () => {
+          const tooLong = _isValidWildcardMatch(
+              'companies/{company}/users/{user}',
+              'companies/firebase/users/abe/boots');
+          expect(tooLong).to.equal(false);
+      });
+
+      it('should not match a path which is too short', () => {
+          const tooShort = _isValidWildcardMatch(
+              'companies/{company}/users/{user}',
+              'companies/firebase/users/');
+          expect(tooShort).to.equal(false);
+      });
+
+      it('should not match a path which has different chunks', () => {
+          const differentChunk = _isValidWildcardMatch(
+              'locations/{company}/users/{user}',
+              'companies/firebase/users/{user}');
+          expect(differentChunk).to.equal(false);
+      });
   });
 
-  describe('#_makeResourceName', () => {
+  describe('#_compiledWildcardPath', () => {
     it('constructs the right resource name from params', () => {
-      const resource = _makeResourceName('companies/{company}/users/{user}', {
+      const resource = _compiledWildcardPath('companies/{company}/users/{user}', {
         company: 'Google',
         user: 'Lauren',
       });

src/main.ts

@@ -20,9 +20,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-import { has, merge, random, get } from 'lodash';
+import { has, merge, random, get, differenceWith } from 'lodash';
 
 import { CloudFunction, EventContext, Change } from 'firebase-functions';
+import {makeDataSnapshot} from './providers/database';
+const wildcardRegex = new RegExp('{[^/{}]*}', 'g');
 
 /** Fields of the event context that can be overridden/customized. */
 export type EventContextOptions = {
@@ -97,14 +99,47 @@ export function wrap<T>(cloudFunction: CloudFunction<T>): WrappedFunction {
     } else {
       _checkOptionValidity(['eventId', 'timestamp', 'params', 'auth', 'authType'], options);
       let eventContextOptions = options as EventContextOptions;
+      const unsafeData = data as any;
+
+      if (typeof unsafeData === 'object' && unsafeData._path) {
+        // Remake the snapshot to standardize the path and remove extra slashes
+        const formattedSnapshotPath = _compiledWildcardPath(
+            unsafeData._path,
+            eventContextOptions ? eventContextOptions.params : null);
+        data = makeDataSnapshot(unsafeData._data, formattedSnapshotPath, unsafeData.app) as any;
+
+        // Ensure the path has no wildcards
+        if (unsafeData._path.match(wildcardRegex)) {
+          throw new Error(`Data path ("${unsafeData._path}") should not contain wildcards.`);
+        }
+
+        // Ensure that the same param wasn't specified by the path and the options.params bundle
+        const pathParams = _extractParamsFromPath(cloudFunction.__trigger.eventTrigger.resource, unsafeData._path);
+        const overlappingWildcards = differenceWith(
+          Object.keys(eventContextOptions.params),
+          Object.keys(pathParams),
+        );
+
+        if (overlappingWildcards.length) {
+          throw new Error(`The same context parameter (${overlappingWildcards.join(', ')}) \
+was supplied by the data path "${unsafeData._path}" and the options bundle "${JSON.stringify(options)}".`);
+        }
+
+        // Build final params bundle
+        eventContextOptions.params = {
+          ...eventContextOptions.params,
+          ...pathParams,
+        };
+      }
+
       const defaultContext: EventContext = {
-          eventId: _makeEventId(),
-          resource: cloudFunction.__trigger.eventTrigger && {
-              service: cloudFunction.__trigger.eventTrigger.service,
-              name: _makeResourceName(
-                cloudFunction.__trigger.eventTrigger.resource,
-                has(eventContextOptions, 'params') && eventContextOptions.params,
-              ),
+        eventId: _makeEventId(),
+        resource: cloudFunction.__trigger.eventTrigger && {
+          service: cloudFunction.__trigger.eventTrigger.service,
+          name: _compiledWildcardPath(
+            cloudFunction.__trigger.eventTrigger.resource,
+            has(eventContextOptions, 'params') && eventContextOptions.params,
+            ),
           },
           eventType: get(cloudFunction, '__trigger.eventTrigger.eventType'),
           timestamp: (new Date()).toISOString(),
@@ -116,6 +151,13 @@ export function wrap<T>(cloudFunction: CloudFunction<T>): WrappedFunction {
         defaultContext.authType = 'UNAUTHENTICATED';
         defaultContext.auth = null;
       }
+
+      if (unsafeData._path &&
+        !_isValidWildcardMatch(cloudFunction.__trigger.eventTrigger.resource, unsafeData._path)) {
+        throw new Error(`Provided path ${_trimSlashes(unsafeData._path)} \
+does not match trigger template ${_trimSlashes(cloudFunction.__trigger.eventTrigger.resource)}`);
+      }
+
       context = merge({}, defaultContext, eventContextOptions);
     }
 
@@ -129,14 +171,54 @@ export function wrap<T>(cloudFunction: CloudFunction<T>): WrappedFunction {
 }
 
 /** @internal */
-export function _makeResourceName(triggerResource: string, params = {}): string {
-  const wildcardRegex = new RegExp('{[^/{}]*}', 'g');
+export function _compiledWildcardPath(triggerResource: string, params = {}): string {
   let resourceName = triggerResource.replace(wildcardRegex, (wildcard) => {
     let wildcardNoBraces = wildcard.slice(1, -1); // .slice removes '{' and '}' from wildcard
     let sub = get(params, wildcardNoBraces);
     return sub || wildcardNoBraces + random(1, 9);
   });
-  return resourceName;
+
+  return _trimSlashes(resourceName);
+}
+
+export function _extractParamsFromPath(wildcardPath, snapshotPath) {
+  if (!_isValidWildcardMatch(wildcardPath, snapshotPath)) {
+    return {};
+  }
+
+  const wildcardKeyRegex = /{(.+)}/;
+  const wildcardChunks = _trimSlashes(wildcardPath).split('/');
+  const snapshotChucks = _trimSlashes(snapshotPath).split('/');
+  return wildcardChunks.slice(-snapshotChucks.length).reduce((params, chunk, index) => {
+    let match = wildcardKeyRegex.exec(chunk);
+    if (match) {
+        const wildcardKey = match[1];
+        const potentialWildcardValue = snapshotChucks[index];
+        if (!wildcardKeyRegex.exec(potentialWildcardValue)) {
+          params[wildcardKey] = potentialWildcardValue;
+        }
+    }
+    return params;
+  }, {});
+}
+
+export function _isValidWildcardMatch(wildcardPath, snapshotPath) {
+  const wildcardChunks = _trimSlashes(wildcardPath).split('/');
+  const snapshotChucks = _trimSlashes(snapshotPath).split('/');
+
+  if (snapshotChucks.length > wildcardChunks.length) {
+    return false;
+  }
+
+  const mismatchedChunks = wildcardChunks.slice(-snapshotChucks.length).filter((chunk, index) => {
+    return !(wildcardRegex.exec(chunk) || chunk === snapshotChucks[index]);
+  });
+
+  return !mismatchedChunks.length;
+}
+
+export function _trimSlashes(path: string) {
+  return path.split('/').filter((c) => c).join('/');
 }
 
 function _makeEventId(): string {

src/providers/database.ts

@@ -30,7 +30,7 @@ export function makeDataSnapshot(
   /** Value of data for the snapshot. */
   val: string | number | boolean | any[] | object,
   /** Full path of the reference (e.g. 'users/alovelace'). */
-  refPath: string,
+  refPath?: string,
   /** The Firebase app that the database belongs to.
    * The databaseURL supplied when initializing the app will be used for creating this snapshot.
    * You do not need to supply this parameter if you supplied Firebase config values when initializing