Merge branch 'master' of https://github.com/firebase/firebase-functions into launch.next

Author: taeold

package-lock.json

@@ -1,5 +1,5 @@
-import { stackToWire, ManifestStack } from "../../src/runtime/manifest";
 import { expect } from "chai";
+import { stackToWire, ManifestStack } from "../../src/runtime/manifest";
 import * as params from "../../src/params";
 
 describe("stackToWire", () => {

spec/runtime/manifest.spec.ts

@@ -1,4 +1,5 @@
 import { expect } from "chai";
+import { CloudEvent } from "../../../../src/v2";
 import * as options from "../../../../src/v2/options";
 import * as alerts from "../../../../src/v2/providers/alerts";
 import { FULL_ENDPOINT, FULL_OPTIONS } from "../fixtures";
@@ -166,4 +167,41 @@ describe("alerts", () => {
       expect(appId).to.be.equal(myOpts.appId);
     });
   });
+
+  describe('convertAlertAndApp', () => {
+    const event: CloudEvent<string> = {
+      specversion: '1.0',
+      id: 'id',
+      source: 'source',
+      type: 'type',
+      time: 'now',
+      data: 'data',
+    };
+
+    it('should leave event unchanged if alerttype & appid are missing', () => {
+      const raw = { ...event };
+
+      const converted = alerts.convertAlertAndApp(raw);
+
+      expect(raw).to.deep.eq(converted);
+    });
+
+    it('should convert alerttype & appid when present', () => {
+      const raw = {
+        ...event,
+        alerttype: 'my-alert',
+        appid: 'my-app',
+      };
+
+      const converted = alerts.convertAlertAndApp(raw);
+
+      expect(converted).to.deep.eq({
+        ...event,
+        alerttype: 'my-alert',
+        appid: 'my-app',
+        alertType: 'my-alert',
+        appId: 'my-app',
+      });
+    });
+  });
 });

spec/v2/providers/alerts/alerts.spec.ts

@@ -0,0 +1,168 @@
+import { expect } from 'chai';
+import * as alerts from '../../../../src/v2/providers/alerts';
+import * as performance from '../../../../src/v2/providers/alerts/performance';
+import { FULL_ENDPOINT, FULL_OPTIONS } from '../fixtures';
+
+const APPID = '123456789';
+const myHandler = () => 42;
+
+const APP_EVENT_FILTER = {
+  appid: APPID,
+};
+
+describe('performance', () => {
+  describe('onThresholdAlertPublished', () => {
+    it('should create a function with alertType & appId', () => {
+      const func = performance.onThresholdAlertPublished(APPID, myHandler);
+
+      expect(func.__endpoint).to.deep.equal({
+        platform: 'gcfv2',
+        labels: {},
+        eventTrigger: {
+          eventType: alerts.eventType,
+          eventFilters: {
+            ...APP_EVENT_FILTER,
+            alerttype: performance.thresholdAlert,
+          },
+          retry: false,
+        },
+      });
+    });
+
+    it('should create a function with opts', () => {
+      const func = performance.onThresholdAlertPublished(
+        { ...FULL_OPTIONS },
+        myHandler
+      );
+
+      expect(func.__endpoint).to.deep.equal({
+        ...FULL_ENDPOINT,
+        eventTrigger: {
+          eventType: alerts.eventType,
+          eventFilters: {
+            alerttype: performance.thresholdAlert,
+          },
+          retry: false,
+        },
+      });
+    });
+
+    it('should create a function with appid in opts', () => {
+      const func = performance.onThresholdAlertPublished(
+        { ...FULL_OPTIONS, appId: APPID },
+        myHandler
+      );
+
+      expect(func.__endpoint).to.deep.equal({
+        ...FULL_ENDPOINT,
+        eventTrigger: {
+          eventType: alerts.eventType,
+          eventFilters: {
+            ...APP_EVENT_FILTER,
+            alerttype: performance.thresholdAlert,
+          },
+          retry: false,
+        },
+      });
+    });
+
+    it('should create a function without opts or appId', () => {
+      const func = performance.onThresholdAlertPublished(myHandler);
+
+      expect(func.__endpoint).to.deep.equal({
+        platform: 'gcfv2',
+        labels: {},
+        eventTrigger: {
+          eventType: alerts.eventType,
+          eventFilters: {
+            alerttype: performance.thresholdAlert,
+          },
+          retry: false,
+        },
+      });
+    });
+
+    it('should create a function with a run method', () => {
+      const func = performance.onThresholdAlertPublished(
+        APPID,
+        (event) => event
+      );
+
+      const res = func.run('input' as any);
+
+      expect(res).to.equal('input');
+    });
+  });
+
+  describe('getOptsAndApp', () => {
+    it('should parse a string', () => {
+      const [opts, appId] = performance.getOptsAndApp(APPID);
+
+      expect(opts).to.deep.equal({});
+      expect(appId).to.equal(APPID);
+    });
+
+    it('should parse an options object without appId', () => {
+      const myOpts: performance.PerformanceOptions = {
+        region: 'us-west1',
+      };
+
+      const [opts, appId] = performance.getOptsAndApp(myOpts);
+
+      expect(opts).to.deep.equal({ region: 'us-west1' });
+      expect(appId).to.be.undefined;
+    });
+
+    it('should parse an options object with appId', () => {
+      const myOpts: performance.PerformanceOptions = {
+        appId: APPID,
+        region: 'us-west1',
+      };
+
+      const [opts, appId] = performance.getOptsAndApp(myOpts);
+
+      expect(opts).to.deep.equal({ region: 'us-west1' });
+      expect(appId).to.equal(APPID);
+    });
+  });
+
+  describe('convertPayload', () => {
+    it('should return the same payload', () => {
+      const payload = {
+        a: 'b',
+        conditionPercentile: 23,
+        appVersion: '3',
+      };
+
+      const convertedPayload = performance.convertPayload(payload as any);
+
+      expect(convertedPayload).to.deep.eq(payload);
+    });
+
+    it('should return the same payload if the fields are undefined', () => {
+      const payload = {
+        a: 'b',
+      };
+
+      const convertedPayload = performance.convertPayload(payload as any);
+
+      expect(convertedPayload).to.deep.eq({
+        a: 'b',
+      });
+    });
+
+    it('should remove fields', () => {
+      const payload = {
+        a: 'b',
+        conditionPercentile: 0,
+        appVersion: '',
+      };
+
+      const convertedPayload = performance.convertPayload(payload as any);
+
+      expect(convertedPayload).to.deep.eq({
+        a: 'b',
+      });
+    });
+  });
+});

spec/v2/providers/alerts/performance.spec.ts

@@ -27,14 +27,14 @@
 
 import {
   BooleanParam,
+  Expression,
   FloatParam,
   IntParam,
   ListParam,
   Param,
   ParamOptions,
-  StringParam,
   SecretParam,
-  Expression,
+  StringParam,
 } from "./types";
 
 export { ParamOptions, Expression };

src/params/index.ts

@@ -179,14 +179,14 @@ export interface SelectOptions<T = unknown> {
   value: T;
 }
 
-export type ParamSpec<T extends string | number | boolean | string[]> = {
+export interface ParamSpec<T = unknown> {
   name: string;
   default?: T | Expression<T>;
   label?: string;
   description?: string;
   type: ParamValueType;
   input?: ParamInput<T>;
-};
+}
 
 // N.B: a WireParamSpec is just a ParamSpec with default expressions converted into a CEL literal
 export type WireParamSpec<T extends string | number | boolean | string[]> = {
@@ -266,8 +266,8 @@ export abstract class Param<T extends string | number | boolean | string[]> exte
 }
 
 export class SecretParam {
-  name: string;
   static type: ParamValueType = "secret";
+  name: string;
 
   constructor(name: string) {
     this.name = name;

src/params/types.ts

@@ -71,6 +71,7 @@ export type AlertType =
   | "billing.automatedPlanUpdate"
   | "appDistribution.newTesterIosDevice"
   | "appDistribution.inAppFeedback"
+  | "performance.threshold"
   | string;
 
 /**
@@ -207,7 +208,7 @@ export function onAlertPublished<T extends { ["@type"]: string } = any>(
   const [opts, alertType, appId] = getOptsAndAlertTypeAndApp(alertTypeOrOpts);
 
   const func = (raw: CloudEvent<unknown>) => {
-    return wrapTraceContext(handler)(raw as AlertEvent<T>);
+    return wrapTraceContext(handler(convertAlertAndApp(raw) as AlertEvent<T>));
   };
 
   func.run = handler;
@@ -271,3 +272,22 @@ export function getOptsAndAlertTypeAndApp(
   }
   return [opts, alertType, appId];
 }
+
+/**
+ * Helper function to covert alert type & app id in the CloudEvent to camel case.
+ * @internal
+ */
+export function convertAlertAndApp(
+  raw: CloudEvent<unknown>
+): CloudEvent<unknown> {
+  const event = { ...raw };
+
+  if ('alerttype' in event) {
+    (event as any).alertType = (event as any).alerttype;
+  }
+  if ('appid' in event) {
+    (event as any).appId = (event as any).appid;
+  }
+
+  return event;
+}

src/v2/providers/alerts/alerts.ts

@@ -27,8 +27,9 @@
 
 import { CloudEvent, CloudFunction } from "../../core";
 import * as options from "../../options";
+import { Expression } from "../../params";
 import { wrapTraceContext } from "../../trace";
-import { FirebaseAlertData, getEndpointAnnotation } from "./alerts";
+import { convertAlertAndApp, FirebaseAlertData, getEndpointAnnotation } from "./alerts";
 import { Expression } from "../../../params";
 
 /**
@@ -243,7 +244,9 @@ export function onNewTesterIosDevicePublished(
   const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
 
   const func = (raw: CloudEvent<unknown>) => {
-    return handler(raw as AppDistributionEvent<NewTesterDevicePayload>);
+    return handler(
+      convertAlertAndApp(raw) as AppDistributionEvent<NewTesterDevicePayload>
+    );
   };
 
   func.run = handler;
@@ -306,7 +309,9 @@ export function onInAppFeedbackPublished(
   const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
 
   const func = (raw: CloudEvent<unknown>) => {
-    return wrapTraceContext(handler)(raw as AppDistributionEvent<InAppFeedbackPayload>);
+    return wrapTraceContext(handler(
+      convertAlertAndApp(raw) as AppDistributionEvent<InAppFeedbackPayload>
+    ));
   };
 
   func.run = handler;

src/v2/providers/alerts/appDistribution.ts

@@ -28,6 +28,11 @@
 import { FirebaseAlertData, getEndpointAnnotation } from ".";
 import { CloudEvent, CloudFunction } from "../../core";
 import { wrapTraceContext } from "../../trace";
+import {
+  convertAlertAndApp,
+  FirebaseAlertData,
+  getEndpointAnnotation,
+} from "./alerts";
 import * as options from "../../options";
 
 /**
@@ -152,7 +157,7 @@ export function onOperation<T>(
   }
 
   const func = (raw: CloudEvent<unknown>) => {
-    return wrapTraceContext(handler)(raw as BillingEvent<T>);
+    return wrapTraceContext(handler(convertAlertAndApp(raw) as BillingEvent<T>));
   };
 
   func.run = handler;