v0.4.0 (#60)

* remove cloud namespace (#47)
* remove event.app (#53)
* removed wrapping of old style events
* changed interface definitions to match new EventFlow format
* change version to 0.4.0

Author: laurenzlong

.gitignore

@@ -7,3 +7,4 @@ lib
 coverage
 node_modules
 typings
+.vscode

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "./node_modules/typescript/lib"
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-functions",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Node helpers for Firebase Functions.",
   "main": "lib/index.js",
   "scripts": {

src/builder.ts

@@ -1,7 +1,5 @@
-import * as _ from 'lodash';
-
 import { FirebaseEnv } from './env';
-import { FirebaseEventMetadata, Event, RawEvent } from './event';
+import { Event, RawEvent } from './event';
 
 export interface TriggerAnnotated {
   __trigger: TriggerDefinition;
@@ -12,49 +10,39 @@ export interface TriggerDefinition {
   event: string;
 }
 
+/* A CloudFunction is both an object that exports its trigger definitions at __trigger and
+   can be called as a function using the raw JS API for Google Cloud Functions. */
+export type CloudFunction = TriggerAnnotated & ((event: RawEvent) => PromiseLike<any> | any);
+
 export class FunctionBuilder {
   protected _env: FirebaseEnv;
 
   constructor(env: FirebaseEnv) {
     this._env = env;
   }
 
-  protected _isEventNewFormat(event: {action?: string}): boolean {
-    return /sources\/[^/]+\/actions\/[^/]+/.test(event.action);
-  }
-
   protected _toTrigger(event?: string): TriggerDefinition {
     throw new Error('Unimplemented _toTrigger');
   }
 
-  protected _wrapHandler<EventData, OldRawType>(
-    handler: (event: Event<EventData>) => PromiseLike<any> | any,
-    event: string,
-    additionalMeta: FirebaseEventMetadata,
-  ): TriggerAnnotated & ((raw: OldRawType | RawEvent) => PromiseLike<any> | any) {
-    const wrapped: any = (payload: OldRawType | RawEvent) => {
-      const metadata = <FirebaseEventMetadata>_.extend({}, additionalMeta, payload);
-      return handler(new Event(metadata, this._dataConstructor<EventData, OldRawType>(payload)));
-    };
-
-    return this._makeHandler<EventData>(wrapped, event);
-  }
-
   protected _makeHandler<EventData>(
-    fn: (event: Event<EventData>) => PromiseLike<any> | any,
+    fn: (event?: Event<EventData>) => PromiseLike<any> | any,
     event: string,
-  ): TriggerAnnotated & ((raw: RawEvent) => PromiseLike<any> | any) {
+  ): CloudFunction {
+    let fnWithDataConstructor: any = (payload: RawEvent) => {
+      return fn(new Event(payload, this._dataConstructor<EventData>(payload)));
+    };
     let handler: any = (payload) => {
       return this._env.ready().then(function() {
-        return fn(payload);
+        return fnWithDataConstructor(payload);
       });
     };
     handler.__trigger = this._toTrigger(event);
 
     return handler;
   }
 
-  protected _dataConstructor<EventData, OldRawType>(raw: OldRawType | RawEvent): EventData {
-    return <any>raw;
+  protected _dataConstructor<EventData>(raw: RawEvent): EventData {
+    return raw.data;
   }
 }

src/builders/database-builder.ts

@@ -0,0 +1,56 @@
+import { AuthMode, default as Apps } from '../apps';
+import DatabaseDeltaSnapshot from '../database/delta-snapshot';
+import { Event } from '../event';
+import { FunctionBuilder, TriggerDefinition, CloudFunction } from '../builder';
+import { normalizePath } from '../utils';
+import { FirebaseEnv } from '../env';
+
+export interface DatabaseTriggerDefinition extends TriggerDefinition {
+  path: string;
+}
+
+export interface DatabaseEventData {
+  data: any;
+  delta: any;
+}
+
+export interface DatabaseEvent extends Event<DatabaseEventData> {
+  auth: AuthMode;
+}
+
+export default class DatabaseBuilder extends FunctionBuilder {
+  private _path: string;
+  private _apps: Apps;
+
+  constructor(env: FirebaseEnv, apps: Apps) {
+    super(env);
+    this._apps = apps;
+  }
+
+  path(path: string): DatabaseBuilder {
+    this._path = this._path || '';
+    this._path += normalizePath(path);
+    return this;
+  }
+
+  onWrite(
+    handler: (event: Event<DatabaseDeltaSnapshot>) => PromiseLike<any> | any
+  ): CloudFunction {
+    if (!this._path) {
+      throw new Error('Must call .path(pathValue) before .on() for database function definitions.');
+    }
+    return this._makeHandler(handler, 'data.write');
+  }
+
+  protected _toTrigger(event?: string): DatabaseTriggerDefinition {
+    return {
+      service: 'firebase.database',
+      event: 'write',
+      path: this._path,
+    };
+  }
+
+  protected _dataConstructor(payload: any): DatabaseDeltaSnapshot {
+    return new DatabaseDeltaSnapshot(this._apps, payload);
+  }
+}

src/cloud/https-builder.ts renamed to src/builders/https-builder.ts

@@ -7,20 +7,6 @@ export {
 }
 
 export default class CloudHttpsBuilder extends FunctionBuilder {
-  on(
-    event: string, handler: (req: Request, resp: Response) => void
-  ): ((req: Request, resp: Response) => void) & TriggerAnnotated {
-    if (event !== 'request') {
-      throw new Error(`Provider cloud.http does not support event type "${event}"`);
-    }
-
-    console.warn(
-      'DEPRECATION NOTICE: cloud.http().on("request", handler) is deprecated, use cloud.http().onRequest(handler)'
-    );
-
-    return this.onRequest(handler);
-  }
-
   onRequest(
     handler: (req: Request, resp: Response) => void
   ): ((req: Request, resp: Response) => void) & TriggerAnnotated {

src/cloud/pubsub-builder.ts renamed to src/builders/pubsub-builder.ts

@@ -1,5 +1,5 @@
-import { FunctionBuilder, TriggerAnnotated, TriggerDefinition } from '../builder';
-import { Event, RawEvent } from '../event';
+import { FunctionBuilder, TriggerDefinition, CloudFunction } from '../builder';
+import { Event } from '../event';
 import { FirebaseEnv } from '../env';
 
 export class PubsubMessage {
@@ -38,7 +38,7 @@ export interface CloudPubsubTriggerDefinition extends TriggerDefinition {
   topic: string;
 }
 
-export default class CloudPubsubBuilder extends FunctionBuilder {
+export default class PubsubBuilder extends FunctionBuilder {
   topic: string;
   event: string;
 
@@ -47,45 +47,20 @@ export default class CloudPubsubBuilder extends FunctionBuilder {
     this.topic = topic;
   }
 
-  on(
-    event: string, handler: (event: Event<PubsubMessage>) => PromiseLike<any> | any,
-  ): TriggerAnnotated & ((event: RawEvent | any) => PromiseLike<any> | any) {
-    if (event !== 'message') {
-      throw new Error(`Provider cloud.pubsub does not support event type "${event}"`);
-    }
-
-    console.warn(
-      'DEPRECATION NOTICE: cloud.pubsub("topic").on("message", handler) is deprecated, ' +
-      'use cloud.pubsub("topic").onPublish(handler)'
-    );
-    return this._makeHandler(handler, 'message');
-  }
-
   onPublish(
-    handler: (event: Event<PubsubMessage>) => PromiseLike<any> | any
-  ): TriggerAnnotated & ((event: RawEvent | any) => PromiseLike<any> | any) {
-    return this._wrapHandler(handler, 'message', {
-      action: 'sources/cloud.pubsub/actions/publish',
-      resource: 'projects/' + process.env.GCLOUD_PROJECT + '/topics/' + this.topic,
-    });
+    handler: (event: Event<PubsubMessage>) => PromiseLike<any> | any): CloudFunction {
+    return this._makeHandler(handler, 'topic.publish');
   }
 
   protected _toTrigger(event: string): CloudPubsubTriggerDefinition {
     return {
       service: 'cloud.pubsub',
-      event: event,
+      event: 'message',
       topic: this.topic,
     };
   }
 
   protected _dataConstructor(payload: any): PubsubMessage {
-    if (this._isEventNewFormat(payload)) {
-      return new PubsubMessage(payload.data);
-    }
-
-    return new PubsubMessage({
-      data: new Buffer(JSON.stringify(payload), 'utf8').toString('base64'),
-      attributes: {},
-    });
+    return new PubsubMessage(payload.data);
   }
 }

src/cloud/storage-builder.ts renamed to src/builders/storage-builder.ts

@@ -1,5 +1,5 @@
-import { FunctionBuilder, TriggerDefinition, TriggerAnnotated } from '../builder';
-import { Event, RawEvent } from '../event';
+import { FunctionBuilder, TriggerDefinition, CloudFunction } from '../builder';
+import { Event } from '../event';
 import { FirebaseEnv } from '../env';
 
 export interface StorageObjectAccessControl {
@@ -70,34 +70,17 @@ export default class CloudStorageBuilder extends FunctionBuilder {
     this.bucket = bucket;
   }
 
-  on(
-    event: string, handler: (event: Event<StorageObject>) => PromiseLike<any> | any
-  ): TriggerAnnotated & ((event: RawEvent) => PromiseLike<any> | any) {
-    if (event !== 'change') {
-      throw new Error(`Provider cloud.storage does not support event type "${event}"`);
-    }
-
-    console.warn(
-      'DEPRECATION NOTICE: cloud.storage("bucket").on("change", handler) is deprecated,' +
-      'use cloud.storage("bucket").onChange(handler)'
-    );
-    return this._makeHandler(handler, 'change');
-  }
-
   onChange(
     handler: (event: Event<StorageObject>) => PromiseLike<any>
-  ): TriggerAnnotated & ((event: Event<StorageObject>) => PromiseLike<any> | any) {
-    return this._wrapHandler(handler, 'change', {
-      action: 'sources/cloud.storage/actions/change',
-      resource: 'projects/' + process.env.GCLOUD_PROJECT + '/buckets/' + this.bucket,
-    });
+  ): CloudFunction {
+    return this._makeHandler(handler, 'object.change');
   }
 
   protected _toTrigger(event: string): CloudStorageTriggerDefinition {
     return {
       service: 'cloud.storage',
       bucket: this.bucket,
-      event,
+      event: 'object',
     };
   }
 }