Support host filter for events (#74)

* support host filter for events

* add host filtering live test

Author: devksingh4

src/api/routes/events.ts

@@ -79,7 +79,11 @@ const getEventJsonSchema = zodToJsonSchema(getEventSchema);
 
 const getEventsSchema = z.array(getEventSchema);
 export type EventsGetResponse = z.infer<typeof getEventsSchema>;
-type EventsGetQueryParams = { upcomingOnly?: boolean };
+type EventsGetQueryParams = {
+  upcomingOnly?: boolean;
+  host?: string;
+  ts?: number;
+};
 
 const eventsPlugin: FastifyPluginAsync = async (fastify, _options) => {
   fastify.post<{ Body: EventPostRequest }>(
@@ -290,29 +294,50 @@ const eventsPlugin: FastifyPluginAsync = async (fastify, _options) => {
           type: "object",
           properties: {
             upcomingOnly: { type: "boolean" },
+            host: { type: "string" },
+            ts: { type: "number" },
           },
         },
         response: { 200: getEventsSchema },
       },
     },
     async (request: FastifyRequest<EventsGetRequest>, reply) => {
       const upcomingOnly = request.query?.upcomingOnly || false;
+      const host = request.query?.host;
+      const ts = request.query?.ts; // we only use this to disable cache control
       const cachedResponse = fastify.nodeCache.get(
-        `events-upcoming_only=${upcomingOnly}`,
+        `events-upcoming_only=${upcomingOnly}|host=${host}`,
       );
       if (cachedResponse) {
         return reply
           .header(
             "cache-control",
-            "public, max-age=7200, stale-while-revalidate=900, stale-if-error=86400",
+            ts
+              ? "no-store, no-cache, max-age=0, must-revalidate, proxy-revalidate"
+              : "public, max-age=7200, stale-while-revalidate=900, stale-if-error=86400",
           )
-          .header("acm-cache-status", "hit")
+          .header("x-acm-cache-status", "hit")
           .send(cachedResponse);
       }
       try {
-        const response = await fastify.dynamoClient.send(
-          new ScanCommand({ TableName: genericConfig.EventsDynamoTableName }),
-        );
+        let command;
+        if (host) {
+          command = new QueryCommand({
+            TableName: genericConfig.EventsDynamoTableName,
+            ExpressionAttributeValues: {
+              ":host": {
+                S: host,
+              },
+            },
+            KeyConditionExpression: "host = :host",
+            IndexName: "HostIndex",
+          });
+        } else {
+          command = new ScanCommand({
+            TableName: genericConfig.EventsDynamoTableName,
+          });
+        }
+        const response = await fastify.dynamoClient.send(command);
         const items = response.Items?.map((item) => unmarshall(item));
         const currentTimeChicago = moment().tz("America/Chicago");
         let parsedItems = getEventsSchema.parse(items);
@@ -354,9 +379,11 @@ const eventsPlugin: FastifyPluginAsync = async (fastify, _options) => {
         reply
           .header(
             "cache-control",
-            "public, max-age=7200, stale-while-revalidate=900, stale-if-error=86400",
+            ts
+              ? "no-store, no-cache, max-age=0, must-revalidate, proxy-revalidate"
+              : "public, max-age=7200, stale-while-revalidate=900, stale-if-error=86400",
           )
-          .header("acm-cache-status", "miss")
+          .header("x-acm-cache-status", "miss")
           .send(parsedItems);
       } catch (e: unknown) {
         if (e instanceof Error) {

tests/live/events.test.ts

@@ -11,6 +11,18 @@ test("getting events", async () => {
   expect(responseJson.length).greaterThan(0);
 });
 
+test("getting events for a given host", async () => {
+  const response = await fetch(`${baseEndpoint}/api/v1/events?host=ACM`);
+  expect(response.status).toBe(200);
+
+  const responseJson = (await response.json()) as EventsGetResponse;
+  expect(responseJson.length).toBeGreaterThan(0);
+
+  responseJson.forEach((event) => {
+    expect(event.host).toBe("ACM");
+  });
+});
+
 describe("Event lifecycle tests", async () => {
   let createdEventUuid;
   test("creating an event", { timeout: 30000 }, async () => {

tests/unit/events.test.ts

@@ -1,12 +1,18 @@
 import { afterAll, expect, test, beforeEach, vi } from "vitest";
-import { ScanCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  ScanCommand,
+  DynamoDBClient,
+  QueryCommand,
+} from "@aws-sdk/client-dynamodb";
 import { mockClient } from "aws-sdk-client-mock";
 import init from "../../src/api/index.js";
 import { EventGetResponse } from "../../src/api/routes/events.js";
 import {
   dynamoTableData,
   dynamoTableDataUnmarshalled,
   dynamoTableDataUnmarshalledUpcomingOnly,
+  infraEventsOnly,
+  infraEventsOnlyUnmarshalled,
 } from "./mockEventData.testdata.js";
 import { secretObject } from "./secret.testdata.js";
 
@@ -58,6 +64,30 @@ test("Test upcoming only", async () => {
   expect(responseDataJson).toEqual(dynamoTableDataUnmarshalledUpcomingOnly);
 });
 
+test("Test host filter", async () => {
+  ddbMock.on(ScanCommand).rejects();
+  ddbMock.on(QueryCommand).resolves({ Items: infraEventsOnly as any });
+  const response = await app.inject({
+    method: "GET",
+    url: "/api/v1/events?host=Infrastructure Committee",
+  });
+  expect(response.statusCode).toBe(200);
+  const responseDataJson = (await response.json()) as EventGetResponse;
+  expect(responseDataJson).toEqual(infraEventsOnlyUnmarshalled);
+  expect(ddbMock.commandCalls(QueryCommand)).toHaveLength(1);
+  const queryCommandCall = ddbMock.commandCalls(QueryCommand)[0].args[0].input;
+  expect(queryCommandCall).toEqual({
+    TableName: "infra-core-api-events",
+    ExpressionAttributeValues: {
+      ":host": {
+        S: "Infrastructure Committee",
+      },
+    },
+    KeyConditionExpression: "host = :host",
+    IndexName: "HostIndex",
+  });
+});
+
 afterAll(async () => {
   await app.close();
   vi.useRealTimers();

tests/unit/mockEventData.testdata.ts

@@ -163,6 +163,16 @@ const dynamoTableData = [
   },
 ];
 
+const infraEventsOnly = dynamoTableData.filter((x) => {
+  return x["host"]["S"] === "Infrastructure Committee";
+});
+
+const infraEventsOnlyUnmarshalled = infraEventsOnly.map((x: any) => {
+  const temp = unmarshall(x);
+  delete temp.createdBy;
+  return temp;
+});
+
 const dynamoTableDataUnmarshalled = dynamoTableData.map((x: any) => {
   const temp = unmarshall(x);
   delete temp.createdBy;
@@ -181,4 +191,6 @@ export {
   dynamoTableData,
   dynamoTableDataUnmarshalled,
   dynamoTableDataUnmarshalledUpcomingOnly,
+  infraEventsOnly,
+  infraEventsOnlyUnmarshalled,
 };