First stab at more granular Datastore event types. Note that tests for write are still failing due to same issue as brought up in Google Group.

Author: asciimike

spec/providers/datastore.spec.ts

@@ -33,75 +33,132 @@ describe('Datastore Functions', () => {
     delete process.env.GCLOUD_PROJECT;
   });
 
-  describe('document builders', () => {
-    function expectedTrigger(resource: string) {
+  describe('document builders and event types', () => {
+    function expectedTrigger(resource: string, eventType: string) {
       return {
         eventTrigger: {
           resource,
-          eventType: `providers/${datastore.provider}/eventTypes/document.write`,
+          eventType: `providers/${datastore.provider}/eventTypes/${eventType}`,
         },
       };
     }
 
     it('should allow terse constructors', () => {
       let resource = 'projects/project1/databases/(default)/documents/users/{uid}';
       let cloudFunction = datastore.document('users/{uid}').onWrite(() => null);
-      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource));
+      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource, 'document.write'));
     });
 
     it('should allow custom namespaces', () => {
       let resource = 'projects/project1/databases/(default)/documents@v2/users/{uid}';
       let cloudFunction = datastore.namespace('v2').document('users/{uid}').onWrite(() => null);
-      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource));
+      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource, 'document.write'));
     });
 
     it('should allow custom databases', () => {
       let resource = 'projects/project1/databases/myDB/documents/users/{uid}';
       let cloudFunction = datastore.database('myDB').document('users/{uid}').onWrite(() => null);
-      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource));
+      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource, 'document.write'));
     });
 
     it('should allow both custom database and namespace', () => {
       let resource = 'projects/project1/databases/myDB/documents@v2/users/{uid}';
       let cloudFunction = datastore.database('myDB').namespace('v2').document('users/{uid}').onWrite(() => null);
-      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource));
+      expect(cloudFunction.__trigger).to.deep.equal(expectedTrigger(resource, 'document.write'));
+    });
+
+    it('onCreate should have the "document.create" eventType', () => {
+      let resource = 'projects/project1/databases/(default)/documents/users/{uid}';
+      let eventType = datastore.document('users/{uid}').onCreate(() => null).__trigger.eventTrigger.eventType;
+      expect(eventType).to.eq(expectedTrigger(resource, 'document.create').eventTrigger.eventType);
+    });
+
+    it('onUpdate should have the "document.update" eventType', () => {
+      let resource = 'projects/project1/databases/(default)/documents/users/{uid}';
+      let eventType = datastore.document('users/{uid}').onUpdate(() => null).__trigger.eventTrigger.eventType;
+      expect(eventType).to.eq(expectedTrigger(resource, 'document.update').eventTrigger.eventType);
+    });
+
+    it('onDelete should have the "document.delete" eventType', () => {
+      let resource = 'projects/project1/databases/(default)/documents/users/{uid}';
+      let eventType = datastore.document('users/{uid}').onDelete(() => null).__trigger.eventTrigger.eventType;
+      expect(eventType).to.eq(expectedTrigger(resource, 'document.delete').eventTrigger.eventType);
     });
   });
 
   describe('dataConstructor', () => {
-    let testEvent = {
-      'data': {
-        'oldValue': {
-          'fields': {
-            'key1': {
-              'booleanValue': false,
-            },
-            'key2': {
-              'integerValue': '111',
+    function testEvent() {
+      return {
+        'data': {
+          'oldValue': {
+            'fields': {
+              'key1': {
+                'booleanValue': false,
+              },
+              'key2': {
+                'integerValue': '111',
+              },
             },
           },
-        },
-        'value': {
-          'fields': {
-            'key1': {
-              'booleanValue': true,
-            },
-            'key2': {
-              'integerValue': '123',
+          'value': {
+            'fields': {
+              'key1': {
+                'booleanValue': true,
+              },
+              'key2': {
+                'integerValue': '123',
+              },
             },
           },
         },
-      },
-    };
+      };
+    }
 
-    it('constructs appropriate fields and getters for event.data', () => {
+    it('constructs appropriate fields and getters for event.data on "document.write" events', () => {
       let testFunction = datastore.document('path').onWrite((event) => {
+        console.log(testEvent());
+        console.log(event);
+        console.log(JSON.stringify(event));
+        expect(event.data.data()).to.deep.equal({key1: true, key2: 123});
+        expect(event.data.get('key1')).to.equal(true);
+        expect(event.data.previous.data()).to.deep.equal({key1: false, key2: 111});
+        expect(event.data.previous.get('key1')).to.equal(false);
+      });
+      return testFunction(testEvent());
+    });
+
+    it('constructs appropriate fields and getters for event.data on "document.create" events', () => {
+      let testFunction = datastore.document('path').onCreate((event) => {
+        expect(event.data.data()).to.deep.equal({key1: true, key2: 123});
+        expect(event.data.get('key1')).to.equal(true);
+        expect(event.data.previous.data()).to.deep.equal({});
+        expect(event.data.previous.get('key1')).to.equal(null);
+      });
+      let event = testEvent();
+      event.data.oldValue = null;
+      return testFunction(event);
+    });
+
+    it('constructs appropriate fields and getters for event.data on "document.update" events', () => {
+      let testFunction = datastore.document('path').onUpdate((event) => {
         expect(event.data.data()).to.deep.equal({key1: true, key2: 123});
         expect(event.data.get('key1')).to.equal(true);
         expect(event.data.previous.data()).to.deep.equal({key1: false, key2: 111});
         expect(event.data.previous.get('key1')).to.equal(false);
       });
-      return testFunction(testEvent);
+      return testFunction(testEvent());
+    });
+
+    it('constructs appropriate fields and getters for event.data on "document.delete" events', () => {
+      let testFunction = datastore.document('path').onDelete((event) => {
+        expect(event.data.data()).to.deep.equal({});
+        expect(event.data.get('key1')).to.equal(null);
+        expect(event.data.previous.data()).to.deep.equal({key1: false, key2: 111});
+        expect(event.data.previous.get('key1')).to.equal(false);
+      });
+      let event = testEvent();
+      event.data.value = null;
+      return testFunction(event);
     });
   });
 

src/providers/datastore.ts

@@ -69,22 +69,49 @@ export class DocumentBuilder {
     // TODO what validation do we want to do here?
   }
 
-  onWrite(handler: (event: Event<any>) => PromiseLike<any> | any): CloudFunction<any> {
-    const dataConstructor = (raw: Event<any>) => {
-      if (raw.data instanceof DeltaDocumentSnapshot) {
-        return raw.data;
-      }
-      return new DeltaDocumentSnapshot(
-        _.get(raw.data, 'value.fields', {}),
-        _.get(raw.data, 'oldValue.fields', {})
-      );
-    };
-    return makeCloudFunction({
-      provider, handler,
-      resource: this.resource,
-      eventType: 'document.write',
-      dataConstructor,
-    });
+  /** Respond to all document writes (creates, updates, or deletes). */
+  onWrite(handler: (event: Event<DeltaDocumentSnapshot>) => PromiseLike<any> |
+  any): CloudFunction<DeltaDocumentSnapshot> {
+    return this.onOperation(handler, 'document.write');
+  }
+
+  /** Respond only to document creations. */
+  onCreate(handler: (event: Event<DeltaDocumentSnapshot>) => PromiseLike<any> |
+  any): CloudFunction<DeltaDocumentSnapshot> {
+    return this.onOperation(handler, 'document.create');
+  }
+
+  /** Respond only to document updates. */
+  onUpdate(handler: (event: Event<DeltaDocumentSnapshot>) => PromiseLike<any> |
+  any): CloudFunction<DeltaDocumentSnapshot> {
+    return this.onOperation(handler, 'document.update');
+  }
+
+  /** Respond only to document deletions. */
+  onDelete(handler: (event: Event<DeltaDocumentSnapshot>) => PromiseLike<any> |
+  any): CloudFunction<DeltaDocumentSnapshot> {
+    return this.onOperation(handler, 'document.delete');
+  }
+
+  private onOperation(
+    handler: (event: Event<DeltaDocumentSnapshot>) => PromiseLike<any> | any,
+    eventType: string): CloudFunction<DeltaDocumentSnapshot> {
+
+      const dataConstructor = (raw: Event<any>) => {
+        if (raw.data instanceof DeltaDocumentSnapshot) {
+          return raw.data;
+        }
+        return new DeltaDocumentSnapshot(
+          _.get(raw.data, 'value.fields', {}),
+          _.get(raw.data, 'oldValue.fields', {})
+        );
+      };
+      return makeCloudFunction({
+        provider, handler,
+        resource: this.resource,
+        eventType: eventType,
+        dataConstructor,
+      });
   }
 }