stuff

Author: devksingh4

cloudformation/iam.yml

@@ -54,6 +54,15 @@ Resources:
               Resource:
                 - !Sub arn:aws:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:infra-events-api-config*
         PolicyName: lambda-db-secrets
+      - PolicyDocument:
+          Version: 2012-10-17
+          Statement:
+            - Action:
+                - dynamodb:*
+              Effect: Allow
+              Resource:
+                - !Sub arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/infra-events-api-records
+        PolicyName: lambda-dynamo
 Outputs:
   MainFunctionRoleArn:
     Description: Main API IAM role ARN

cloudformation/main.yml

@@ -111,6 +111,22 @@ Resources:
             Path: /{proxy+}
             Method: ANY
 
+  EventRecordsTable:
+    Type: 'AWS::DynamoDB::Table'
+    DeletionPolicy: "Retain"  
+    Properties:
+      BillingMode: 'PAY_PER_REQUEST'
+      TableName: infra-events-api-records
+      DeletionProtectionEnabled: true
+      PointInTimeRecoverySpecification:
+        PointInTimeRecoveryEnabled: !If [IsProd, true, false]
+      AttributeDefinitions:
+        - AttributeName: id
+          AttributeType: S
+      KeySchema:
+        - AttributeName: id
+          KeyType: HASH
+
   AppApiGateway:
     Type: AWS::Serverless::Api
     DependsOn: 

package.json

@@ -34,12 +34,16 @@
     "typescript": "^5.5.4"
   },
   "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.624.0",
     "@aws-sdk/client-secrets-manager": "^3.624.0",
+    "@aws-sdk/util-dynamodb": "^3.624.0",
     "@fastify/auth": "^4.6.1",
     "@fastify/aws-lambda": "^4.1.0",
     "fastify": "^4.28.1",
     "fastify-plugin": "^4.5.1",
     "jsonwebtoken": "^9.0.2",
-    "jwks-rsa": "^3.1.0"
+    "jwks-rsa": "^3.1.0",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.23.2"
   }
 }

src/config.ts

@@ -0,0 +1,3 @@
+export default {
+  DYNAMO_TABLE_NAME: "infra-events-api-records",
+};

src/errors/index.ts

@@ -70,3 +70,25 @@ export class NotFoundError extends BaseError<"NotFoundError"> {
     });
   }
 }
+
+export class ValidationError extends BaseError<"ValidationError"> {
+  constructor({ message }: { message: string }) {
+    super({
+      name: "ValidationError",
+      id: 104,
+      message,
+      httpStatusCode: 400,
+    });
+  }
+}
+
+export class DatabaseInsertError extends BaseError<"DatabaseInsertError"> {
+  constructor({ message }: { message: string }) {
+    super({
+      name: "DatabaseInsertError",
+      id: 105,
+      message,
+      httpStatusCode: 500,
+    });
+  }
+}

src/index.ts

@@ -7,6 +7,7 @@ import protectedRoute from "./routes/protected.js";
 import errorHandlerPlugin from "./plugins/errorHandler.js";
 import { RunEnvironment, runEnvironments } from "./roles.js";
 import { InternalServerError } from "./errors/index.js";
+import createEvent from "./routes/event.js";
 
 const now = () => Date.now();
 
@@ -57,6 +58,7 @@ async function init() {
   await app.register(
     async (api, _options) => {
       api.register(protectedRoute, { prefix: "/protected" });
+      api.register(createEvent, { prefix: "/event" });
     },
     { prefix: "/api/v1" },
   );

src/orgs.ts

@@ -0,0 +1,25 @@
+export const SIGList = [
+  "SIGPwny",
+  "SIGCHI",
+  "GameBuilders",
+  "SIGAIDA",
+  "SIGGRAPH",
+  "ICPC",
+  "SIGMobile",
+  "SIGMusic",
+  "GLUG",
+  "SIGNLL",
+  "SIGma",
+  "SIGQuantum",
+  "SIGecom",
+  "SIGPLAN",
+  "SIGPolicy",
+  "SIGARCH",
+] as const;
+
+export const CommitteeList = [
+  "Infrastructure Committe",
+  "Social Committee",
+  "Mentorship Committee",
+] as const;
+export const OrganizationList = ["ACM", ...SIGList, ...CommitteeList] as const;

src/plugins/errorHandler.ts

@@ -1,21 +1,29 @@
-import { FastifyReply, FastifyRequest } from "fastify";
+import { FastifyError, FastifyReply, FastifyRequest } from "fastify";
 import fp from "fastify-plugin";
 import {
   BaseError,
   InternalServerError,
   NotFoundError,
+  ValidationError,
 } from "../errors/index.js";
 
 const errorHandlerPlugin = fp(async (fastify) => {
   fastify.setErrorHandler(
     (err: unknown, request: FastifyRequest, reply: FastifyReply) => {
-      let finalErr = new InternalServerError();
+      let finalErr;
       if (err instanceof BaseError) {
         finalErr = err;
+      } else if (
+        (err as FastifyError).validation ||
+        (err as Error).name === "BadRequestError"
+      ) {
+        finalErr = new ValidationError({
+          message: (err as FastifyError).message,
+        });
       }
-      if (err instanceof BaseError) {
+      if (finalErr && finalErr instanceof BaseError) {
         request.log.error(
-          { errId: err.id, errName: err.name },
+          { errId: finalErr.id, errName: finalErr.name },
           finalErr.toString(),
         );
       } else if (err instanceof Error) {
@@ -26,6 +34,9 @@ const errorHandlerPlugin = fp(async (fastify) => {
       } else {
         request.log.error("Native unhandled error: response sent to client.");
       }
+      if (!finalErr) {
+        finalErr = new InternalServerError();
+      }
       reply.status(finalErr.httpStatusCode).type("application/json").send({
         error: true,
         name: finalErr.name,

src/routes/event.ts

@@ -0,0 +1,75 @@
+import { FastifyPluginAsync } from "fastify";
+import { AppRoles } from "../roles.js";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { OrganizationList } from "../orgs.js";
+import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
+import { marshall } from "@aws-sdk/util-dynamodb";
+import config from "../config.js";
+import { DatabaseInsertError } from "../errors/index.js";
+import { randomUUID } from "crypto";
+
+const repeatOptions = ["weekly", "biweekly"] as const;
+
+const requestBodySchema = z.object({
+  title: z.string().min(1),
+  description: z.string().min(1),
+  start: z.string().datetime(),
+  end: z.optional(z.string().datetime()),
+  location: z.string(),
+  locationLink: z.optional(z.string().url()),
+  repeats: z.optional(z.enum(repeatOptions)),
+  host: z.enum(OrganizationList),
+});
+const requestJsonSchema = zodToJsonSchema(requestBodySchema);
+type EventPostRequest = z.infer<typeof requestBodySchema>;
+
+const responseJsonSchema = zodToJsonSchema(
+  z.object({
+    id: z.string(),
+    resource: z.string(),
+  }),
+);
+
+const dynamoClient = new DynamoDBClient({
+  region: process.env.AWS_REGION || "us-east-1",
+});
+
+const createEvent: FastifyPluginAsync = async (fastify, _options) => {
+  fastify.post<{ Body: EventPostRequest }>(
+    "/",
+    {
+      schema: {
+        body: requestJsonSchema,
+        response: { 200: responseJsonSchema },
+      },
+      onRequest: async (request, reply) => {
+        await fastify.authorize(request, reply, [AppRoles.MANAGER]);
+      },
+    },
+    async (request, reply) => {
+      try {
+        const entryUUID = randomUUID().toString();
+        const dynamoResponse = await dynamoClient.send(
+          new PutItemCommand({
+            TableName: config.DYNAMO_TABLE_NAME,
+            Item: marshall({ ...request.body, id: entryUUID }),
+          }),
+        );
+        reply.send({
+          id: entryUUID,
+          resource: `/api/v1/entry/${entryUUID}`,
+        });
+      } catch (e: unknown) {
+        if (e instanceof Error) {
+          request.log.error("Failed to insert to DynamoDB: " + e.toString());
+        }
+        throw new DatabaseInsertError({
+          message: "Failed to insert event to Dynamo table.",
+        });
+      }
+    },
+  );
+};
+
+export default createEvent;