Add support for firealerts events in Eventarc emulator.

src/emulator/constants.ts

@@ -95,6 +95,7 @@ export class Constants {
   static SERVICE_REALTIME_DATABASE = "firebaseio.com";
   static SERVICE_PUBSUB = "pubsub.googleapis.com";
   static SERVICE_EVENTARC = "eventarc.googleapis.com";
+  static SERVICE_FIREALERTS = "firebasealerts.googleapis.com";
   // Note: the service name below are here solely for logging purposes.
   // There is not an emulator available for these.
   static SERVICE_ANALYTICS = "app-measurement.com";

src/emulator/eventarcEmulator.ts

@@ -10,7 +10,7 @@
 import { FirebaseError } from "../error";
 import { cloudEventFromProtoToJson } from "./eventarcEmulatorUtils";
 
-interface CustomEventTrigger {
+interface EmulatedEventTrigger {
   projectId: string;
   triggerName: string;
   eventTrigger: EventTrigger;
@@ -29,7 +29,8 @@
   private destroyServer?: () => Promise<void>;
 
   private logger = EmulatorLogger.forEmulator(Emulators.EVENTARC);
-  private customEvents: { [key: string]: CustomEventTrigger[] } = {};
+  private customEvents: { [key: string]: EmulatedEventTrigger[] } = {};
+  private nativeEvents: { [key: string]: EmulatedEventTrigger[] } = {};
 
   constructor(private args: EventarcEmulatorArgs) {}
 
@@ -46,32 +47,48 @@
       }
       const bodyString = (req as RequestWithRawBody).rawBody.toString();
       const substituted = bodyString.replaceAll("${PROJECT_ID}", projectId);
       const body = JSON.parse(substituted);
       const eventTrigger = body.eventTrigger as EventTrigger;
       if (!eventTrigger) {
         const error = `Missing event trigger for ${triggerName}.`;
         this.logger.log("ERROR", error);
         res.status(400).send({ error });
         return;
       }
-      const key = `${eventTrigger.eventType}-${eventTrigger.channel}`;
-      this.logger.logLabeled(
-        "BULLET",
-        "eventarc",
-        `Registering custom event trigger for ${key} with trigger name ${triggerName}.`,
-      );
-      const customEventTriggers = this.customEvents[key] || [];
-      customEventTriggers.push({ projectId, triggerName, eventTrigger });
-      this.customEvents[key] = customEventTriggers;
+      if (eventTrigger.channel) {
+        const key = `${eventTrigger.eventType}-${eventTrigger.channel}`;
+        this.logger.logLabeled(
+          "BULLET",
+          "eventarc",
+          `Registering custom event trigger for ${key} with trigger name ${triggerName}.`,
+        );
+        const customEventTriggers = this.customEvents[key] || [];
+        customEventTriggers.push({ projectId, triggerName, eventTrigger });
+        this.customEvents[key] = customEventTriggers;
+      } else {
+        this.logger.logLabeled(
+          "BULLET",
+          "eventarc",
+          `Registering custom event trigger for ${eventTrigger.eventType} with trigger name ${triggerName}.`,
+        );
+        const nativeEventTriggers = this.nativeEvents[eventTrigger.eventType] || [];
+        nativeEventTriggers.push({ projectId, triggerName, eventTrigger });
+        this.nativeEvents[eventTrigger.eventType] = nativeEventTriggers;
+      }
       res.status(200).send({ res: "OK" });
     };
 
+    const getTriggersRoute = `/google/getTriggers`;
+    const getTriggersHandler: express.RequestHandler = (req, res) => {
+      res.status(200).send(this.nativeEvents);
+    };
+
     const publishEventsRoute = `/projects/:project_id/locations/:location/channels/:channel::publishEvents`;
     const publishEventsHandler: express.RequestHandler = (req, res) => {
       const channel = `projects/${req.params.project_id}/locations/${req.params.location}/channels/${req.params.channel}`;
       const body = JSON.parse((req as RequestWithRawBody).rawBody.toString());
       for (const event of body.events) {
         if (!event.type) {
           res.sendStatus(400);
           return;
         }
@@ -79,7 +96,7 @@
           "INFO",
           `Received custom event at channel ${channel}: ${JSON.stringify(event, null, 2)}`,
         );
         this.triggerCustomEventFunction(channel, event);
       }
       res.sendStatus(200);
     };
@@ -95,17 +112,33 @@
       });
     };
 
+    const publishNativeEventsRoute = `/google/publishEvents`;
+    const publishNativeEventsHandler: express.RequestHandler = (req, res) => {
+      const body = JSON.parse((req as RequestWithRawBody).rawBody.toString());
+      for (const event of body.events as CloudEvent<any>[]) {
+        if (!event.type) {
+          res.sendStatus(400);
+          return;
+        }
+        this.logger.log("INFO", `Received ${event.type} event: ${JSON.stringify(event, null, 2)}`);
+        void this.triggerNativeEventFunction(event);
+      }
+      res.sendStatus(200);
+    };
+
     const hub = express();
     hub.post([registerTriggerRoute], dataMiddleware, registerTriggerHandler);
     hub.post([publishEventsRoute], dataMiddleware, publishEventsHandler);
+    hub.post([publishNativeEventsRoute], dataMiddleware, publishNativeEventsHandler);
+    hub.get([getTriggersRoute], dataMiddleware, getTriggersHandler);
     hub.all("*", (req, res) => {
       this.logger.log("DEBUG", `Eventarc emulator received unknown request at path ${req.path}`);
       res.sendStatus(404);
     });
     return hub;
   }
 
-  async triggerCustomEventFunction(channel: string, event: CloudEvent<any>) {
+  async triggerCustomEventFunction(channel: string, event: CloudEvent<any>): Promise<void[]> {
     if (!EmulatorRegistry.isRunning(Emulators.FUNCTIONS)) {
       this.logger.log("INFO", "Functions emulator not found. This should not happen.");
       return Promise.reject();
@@ -119,31 +152,50 @@
             !trigger.eventTrigger.eventFilters ||
             this.matchesAll(event, trigger.eventTrigger.eventFilters),
         )
-        .map((trigger) =>
-          EmulatorRegistry.client(Emulators.FUNCTIONS)
-            .request<CloudEvent<any>, NodeJS.ReadableStream>({
-              method: "POST",
-              path: `/functions/projects/${trigger.projectId}/triggers/${trigger.triggerName}`,
-              body: JSON.stringify(cloudEventFromProtoToJson(event)),
-              responseType: "stream",
-              resolveOnHTTPError: true,
-            })
-            .then((res) => {
-              // Since the response type is a stream and using `resolveOnHTTPError: true`, we check status manually.
-              if (res.status >= 400) {
-                throw new FirebaseError(`Received non-200 status code: ${res.status}`);
-              }
-            })
-            .catch((err) => {
-              this.logger.log(
-                "ERROR",
-                `Failed to trigger Functions emulator for ${trigger.triggerName}: ${err}`,
-              );
-            }),
-        ),
+        .map((trigger) => this.callFunctionTrigger(trigger, cloudEventFromProtoToJson(event))),
+    );
+  }
+
+  async triggerNativeEventFunction(event: CloudEvent<any>) {
+    if (!EmulatorRegistry.isRunning(Emulators.FUNCTIONS)) {
+      this.logger.log("INFO", "Functions emulator not found. This should not happen.");
+      return Promise.reject();
+    }
+    const triggers = this.nativeEvents[event.type] || [];
+    return await Promise.all(
+      triggers
+        .filter(
+          (trigger) =>
+            !trigger.eventTrigger.eventFilters ||
+            this.matchesAll(event, trigger.eventTrigger.eventFilters),
+        )
+        .map((trigger) => this.callFunctionTrigger(trigger, event)),
     );
   }
 
+  callFunctionTrigger(trigger: EmulatedEventTrigger, event: CloudEvent<any>): Promise<void> {
+    return EmulatorRegistry.client(Emulators.FUNCTIONS)
+      .request<CloudEvent<any>, NodeJS.ReadableStream>({
+        method: "POST",
+        path: `/functions/projects/${trigger.projectId}/triggers/${trigger.triggerName}`,
+        body: JSON.stringify(event),
+        responseType: "stream",
+        resolveOnHTTPError: true,
+      })
+      .then((res) => {
+        // Since the response type is a stream and using `resolveOnHTTPError: true`, we check status manually.
+        if (res.status >= 400) {
+          throw new FirebaseError(`Received non-200 status code: ${res.status}`);
+        }
+      })
+      .catch((err) => {
+        this.logger.log(
+          "ERROR",
+          `Failed to trigger Functions emulator for ${trigger.triggerName}: ${err}`,
+        );
+      });
+  }
+
   private matchesAll(event: CloudEvent<any>, eventFilters: Record<string, string>): boolean {
     return Object.entries(eventFilters).every(([key, value]) => {
       let attr = event[key] ?? event.attributes[key];

src/emulator/functionsEmulator.ts

@@ -682,6 +682,13 @@ export class FunctionsEmulator implements EmulatorInstance {
           case Constants.SERVICE_STORAGE:
             added = this.addStorageTrigger(this.args.projectId, key, definition.eventTrigger);
             break;
+          case Constants.SERVICE_FIREALERTS:
+            added = await this.addFirealertsTrigger(
+              this.args.projectId,
+              key,
+              definition.eventTrigger,
+            );
+            break;
           default:
             this.logger.log("DEBUG", `Unsupported trigger: ${JSON.stringify(definition)}`);
             break;
@@ -768,6 +775,30 @@ export class FunctionsEmulator implements EmulatorInstance {
       });
   }
 
+  addFirealertsTrigger(
+    projectId: string,
+    key: string,
+    eventTrigger: EventTrigger,
+  ): Promise<boolean> {
+    if (!EmulatorRegistry.isRunning(Emulators.EVENTARC)) {
+      return Promise.resolve(false);
+    }
+    const bundle = {
+      eventTrigger: {
+        ...eventTrigger,
+        service: "firebasealerts.googleapis.com",
+      },
+    };
+    logger.debug(`addFirealertsTrigger`, JSON.stringify(bundle));
+    return EmulatorRegistry.client(Emulators.EVENTARC)
+      .post(`/emulator/v1/projects/${projectId}/triggers/${key}`, bundle)
+      .then(() => true)
+      .catch((err) => {
+        this.logger.log("WARN", "Error adding FireAlerts function: " + err);
+        return false;
+      });
+  }
+
   async performPostLoadOperations(): Promise<void> {
     if (
       !this.blockingFunctionsConfig.triggers &&

src/emulator/functionsEmulatorShared.ts

@@ -21,6 +21,7 @@ import { connectableHostname } from "../utils";
 /** The current v2 events that are implemented in the emulator */
 const V2_EVENTS = [
   events.v2.PUBSUB_PUBLISH_EVENT,
+  events.v2.FIREALERTS_EVENT,
   ...events.v2.STORAGE_EVENTS,
   ...events.v2.DATABASE_EVENTS,
   ...events.v2.FIRESTORE_EVENTS,
@@ -367,6 +368,9 @@ export function getServiceFromEventType(eventType: string): string {
   if (eventType.includes("storage")) {
     return Constants.SERVICE_STORAGE;
   }
+  if (eventType.includes("firebasealerts")) {
+    return Constants.SERVICE_FIREALERTS;
+  }
   // Below this point are services that do not have a emulator.
   if (eventType.includes("analytics")) {
     return Constants.SERVICE_ANALYTICS;

src/functions/events/v2.ts

@@ -30,6 +30,9 @@ export const FIRESTORE_EVENTS = [
   "google.cloud.firestore.document.v1.updated.withAuthContext",
   "google.cloud.firestore.document.v1.deleted.withAuthContext",
 ] as const;
+
+export const FIREALERTS_EVENT = "google.firebase.firebasealerts.alerts.v1.published";
+
 export const FIRESTORE_EVENT_REGEX = /^google\.cloud\.firestore\.document\.v1\.[^\.]*$/;
 export const FIRESTORE_EVENT_WITH_AUTH_CONTEXT_REGEX =
   /^google\.cloud\.firestore\.document\.v1\..*\.withAuthContext$/;
@@ -41,4 +44,5 @@ export type Event =
   | (typeof DATABASE_EVENTS)[number]
   | typeof REMOTE_CONFIG_EVENT
   | typeof TEST_LAB_EVENT
-  | (typeof FIRESTORE_EVENTS)[number];
+  | (typeof FIRESTORE_EVENTS)[number]
+  | typeof FIREALERTS_EVENT;