Serve stored messages from API

Author: vcarl

src/features/jobs-moderation/job-mod-helpers.ts

@@ -73,13 +73,22 @@ interface StoredMessage {
   message: Message;
   authorId: Snowflake;
   createdAt: Date;
+  description: string;
+  tags: string[];
   type: PostType;
 }
 let jobBoardMessageCache: {
   forHire: StoredMessage[];
   hiring: StoredMessage[];
 } = { forHire: [], hiring: [] };
 
+export const getJobPosts = () => {
+  return {
+    hiring: jobBoardMessageCache.hiring,
+    forHire: jobBoardMessageCache.forHire,
+  };
+};
+
 const DAYS_OF_POSTS = 30;
 
 export const loadJobs = async (bot: Client, channel: TextChannel) => {
@@ -100,18 +109,21 @@ export const loadJobs = async (bot: Client, channel: TextChannel) => {
       })
     )
       // Convert fetched messages to be stored in the cache
-      .map((message) => ({
-        message,
-        authorId: message.author.id,
-        createdAt: message.createdAt,
-        // By searching for "hiring", we treat posts without tags as "forhire",
-        // which makes the subject to deletion after aging out. This will only be
-        // relevant when this change is first shipped, because afterwards all
-        // un-tagged posts will be removed.
-        type: parseContent(message.content)[0].tags.includes("hiring")
-          ? PostType.hiring
-          : PostType.forHire,
-      }));
+      .map((message) => {
+        const { tags, description } = parseContent(message.content)[0];
+        return {
+          message,
+          authorId: message.author.id,
+          createdAt: message.createdAt,
+          description,
+          tags,
+          // By searching for "hiring", we treat posts without tags as "forhire",
+          // which makes the subject to deletion after aging out. This will only be
+          // relevant when this change is first shipped, because afterwards all
+          // un-tagged posts will be removed.
+          type: tags.includes("hiring") ? PostType.hiring : PostType.forHire,
+        };
+      });
     if (newMessages.length === 0) {
       break;
     }
@@ -230,6 +242,8 @@ export const updateJobs = (message: Message) => {
     message,
     authorId: message.author.id,
     createdAt: message.createdAt,
+    description: parsed.description,
+    tags: parsed.tags,
     type,
   });
 

src/server.ts

@@ -1,88 +1,106 @@
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import helmet from "@fastify/helmet";
-import rateLimit from "@fastify/rate-limit";
 import swagger from "@fastify/swagger";
+import { getJobPosts } from "./features/jobs-moderation/job-mod-helpers";
 
-const fastify = Fastify({
-  logger: {
-    transport: {
-      target: "pino-pretty",
+const fastify = Fastify({ logger: true });
+
+const openApiConfig = {
+  openapi: "3.0.0",
+  info: {
+    title: "Job Board API",
+    version: "1.0.0",
+  },
+  components: {
+    schemas: {
+      JobPost: {
+        type: "object",
+        required: ["tags", "description", "authorId", "message", "createdAt"],
+        properties: {
+          tags: {
+            type: "array",
+            items: { type: "string" },
+          },
+          description: { type: "string" },
+          authorId: {
+            type: "string",
+            format: "snowflake",
+          },
+          message: {
+            type: "object",
+            description: "Discord Message object",
+          },
+          createdAt: {
+            type: "string",
+            format: "date-time",
+          },
+        },
+      },
+      JobBoardCache: {
+        type: "object",
+        required: ["forHire", "hiring"],
+        properties: {
+          forHire: {
+            type: "array",
+            items: { $ref: "JobPost" },
+          },
+          hiring: {
+            type: "array",
+            items: { $ref: "JobPost" },
+          },
+        },
+      },
     },
   },
-});
-
-// Swagger documentation
-const swaggerConfig = {
-  swagger: {
-    info: {
-      title: "API Documentation",
-      version: "1.0.0",
+  paths: {
+    "/jobs": {
+      get: {
+        tags: ["jobs"],
+        summary: "Get all job posts",
+        responses: {
+          "200": {
+            description: "Successful response",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "JobBoardCache",
+                },
+              },
+            },
+          },
+        },
+      },
     },
   },
 };
 
-// Register plugins
-await fastify.register(cors);
-await fastify.register(helmet);
-await fastify.register(rateLimit, {
-  max: 100,
-  timeWindow: "1 minute",
-});
-await fastify.register(swagger, swaggerConfig);
-
-// Example route with schema validation
-// fastify.get(
-//   "/items",
-//   {
-//     schema: {
-//       response: {
-//         200: {
-//           type: "array",
-//           items: {
-//             type: "object",
-//             properties: {
-//               id: { type: "string" },
-//               name: { type: "string" },
-//             },
-//           },
-//         },
-//       },
-//     },
-//   },
-//   async (request, reply) => {
-//     return [{ id: "1", name: "Item 1" }];
-//   },
-// );
+try {
+  Object.entries(openApiConfig.components.schemas).forEach(([k, schema]) => {
+    fastify.addSchema({ ...schema, $id: k });
+  });
+  // @ts-expect-error something's busted but it works
+  await fastify.register(swagger, openApiConfig);
+  await fastify.register(cors);
+  await fastify.register(helmet);
+} catch (e) {
+  console.log(e);
+}
 
 fastify.get(
-  "/",
+  "/jobs",
   {
     schema: {
       response: {
         200: {
-          type: "object",
-          properties: {
-            hello: { type: "string" },
-          },
+          $ref: "JobBoardCache",
         },
       },
     },
   },
   async () => {
-    return { hello: "world" };
+    return getJobPosts();
   },
 );
 
-// Error handler
-fastify.setErrorHandler((error, request, reply) => {
-  fastify.log.error(error);
-  reply.status(500).send({ error: "Internal Server Error" });
-});
-
-try {
-  await fastify.listen({ port: 3000 });
-} catch (err) {
-  fastify.log.error(err);
-  process.exit(1);
-}
+await fastify.listen({ port: 3000 });