From be13960bb99511d0321f0426a0bfb3cffb8e7f3a Mon Sep 17 00:00:00 2001
From: Samuel Shuert <me@thecoded.prof>
Date: Fri, 12 Dec 2025 18:08:14 +0000
Subject: [PATCH] feat: Dec 11

---
 react/src/App.tsx |   4 +-
 server/books.ts   |  10 +-
 server/index.ts   |   2 +
 server/posts.ts   | 410 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 419 insertions(+), 7 deletions(-)
 create mode 100644 server/posts.ts

diff --git a/react/src/App.tsx b/react/src/App.tsx
index 4d0904a..d1bf6c7 100644
--- a/react/src/App.tsx
+++ b/react/src/App.tsx
@@ -9,7 +9,7 @@ export function App() {
     <>
       <title>Posts</title>
       <div className="w-screen p-5 flex flex-col items-center gap-10">
-        <nav className="flex justify-between items-center w-full sticky top-0">
+        <nav className="flex justify-between items-center w-full sticky top-0 max-w-3xl">
           <h1 className="text-3xl font-bold text-left">Blog App</h1>
           {searchBarDisplay ? (
             <>
@@ -17,7 +17,7 @@ export function App() {
                 type="text"
                 placeholder="Search..."
                 className="border border-gray-300 rounded px-2 py-1"
-                onChange={(e) => {
+                onChange={(_e) => {
                   // Implement search functionality here
                 }}
               />
diff --git a/server/books.ts b/server/books.ts
index 27c0729..5e1315f 100644
--- a/server/books.ts
+++ b/server/books.ts
@@ -128,14 +128,14 @@ const keyTypes = {
   author: "string",
 };
 
-const validateBook = (task: { [key: string]: any }): Book => {
+const validateBook = (book: { [key: string]: any }): Book => {
   let missingKeys = ["id", "title", "author"].filter(
-    (key) => !Object.keys(task).includes(key),
+    (key) => !Object.keys(book).includes(key),
   );
-  let extraKeys = Object.keys(task).filter(
+  let extraKeys = Object.keys(book).filter(
     (key) => !["id", "title", "author"].includes(key),
   );
-  let badValues = Object.entries(task)
+  let badValues = Object.entries(book)
     .filter(([key, value]) => {
       if (key === "id") return typeof value !== "string" || !ISBN13.test(value);
       if (key === "title") return typeof value !== "string";
@@ -149,7 +149,7 @@ const validateBook = (task: { [key: string]: any }): Book => {
   if (missingKeys.length > 0 || extraKeys.length > 0 || badValues.length > 0) {
     throw new BadDataIssues(missingKeys, extraKeys, badValues);
   }
-  return task as Book;
+  return book as Book;
 };
 
 const auth = async (req: Request, res: Response, next: NextFunction) => {
diff --git a/server/index.ts b/server/index.ts
index 6dbf1a2..8061f20 100644
--- a/server/index.ts
+++ b/server/index.ts
@@ -1,12 +1,14 @@
 import express from "express";
 import tasks from "./tasks.ts";
 import books from "./books.ts";
+import posts from "./posts.ts";
 
 const app = express();
 const port = process.env["NODE_PORT"] ?? 5173;
 
 app.use("/tasks", tasks);
 app.use("/books", books);
+app.use("/posts", posts);
 
 app.listen(port, () => {
   console.log(`Server listening on port ${port}`);
diff --git a/server/posts.ts b/server/posts.ts
new file mode 100644
index 0000000..064dcf1
--- /dev/null
+++ b/server/posts.ts
@@ -0,0 +1,410 @@
+import express, {
+  type NextFunction,
+  type Request,
+  type Response,
+} from "express";
+import { writeFile, exists, readFile } from "fs/promises";
+
+const uuidv7 = /^[0-9a-f]{8}(?:\-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
+
+interface Comment {
+  id: string;
+  author: string;
+  content: string;
+}
+
+interface Post {
+  id: string;
+  title: string;
+  author: string;
+  publicationDate: number;
+  readTime: number;
+  content: string;
+  likes: number;
+  tags: string[];
+  comments: Comment[];
+}
+
+const getPosts: () => Promise<Post[]> = async () => {
+  if (!(await exists("posts.json"))) {
+    await writeFile("posts.json", JSON.stringify([]));
+  }
+  const file = await readFile("posts.json", "utf-8");
+  if (file.length === 0) {
+    return [];
+  }
+  return JSON.parse(file);
+};
+
+const updatePost = async (post: Post): Promise<void> => {
+  const posts = await getPosts();
+  const index = posts.findIndex((t) => t.id === post.id);
+  if (index !== -1) {
+    posts[index] = post;
+  } else {
+    posts.push(post);
+  }
+  await writeFile("posts.json", JSON.stringify(posts));
+};
+
+const deletePost = async (id: string): Promise<void> => {
+  const posts = await getPosts();
+  const index = posts.findIndex((t) => t.id === id);
+  if (index !== -1) {
+    posts.splice(index, 1);
+    await writeFile("posts.json", JSON.stringify(posts));
+  }
+};
+
+const keyTypes = {
+  title: "string",
+  author: "string",
+  content: "string",
+};
+
+class BadDataIssues extends Error {
+  constructor(
+    public missingKeys: string[],
+    public extraKeys: string[],
+    public badValues: [string, string][],
+  ) {
+    super("Bad data issues");
+  }
+}
+
+const validateUpdate = (post: Record<string, any>) => {
+  let missingKeys = ["title", "author", "content", "tags"].filter(
+    (key) => !Object.keys(post).includes(key),
+  );
+  let extraKeys = Object.keys(post).filter(
+    (key) => !["title", "author", "content", "tags"].includes(key),
+  );
+  let badValues = Object.entries(post)
+    .filter(([key, value]) => {
+      if (key === "title") return typeof value !== "string";
+      if (key === "author") return typeof value !== "string";
+      if (key === "content") return typeof value !== "string";
+      if (key === "tags")
+        return (
+          !Array.isArray(value) ||
+          !value.every((tag) => typeof tag === "string")
+        );
+      return false;
+    })
+    .map(
+      ([key, _value]) =>
+        [key, keyTypes[key as keyof typeof keyTypes]] as [string, string],
+    );
+  if (missingKeys.length > 0 || extraKeys.length > 0 || badValues.length > 0) {
+    throw new BadDataIssues(missingKeys, extraKeys, badValues);
+  }
+  return post as Pick<Post, "title" | "author" | "content" | "tags">;
+};
+
+const validateComment = (comment: Record<string, any>) => {
+  let missingKeys = ["author", "content"].filter(
+    (key) => !Object.keys(comment).includes(key),
+  );
+  let extraKeys = Object.keys(comment).filter(
+    (key) => !["author", "content"].includes(key),
+  );
+  let badValues = Object.entries(comment)
+    .filter(([key, value]) => {
+      if (key === "author") return typeof value !== "string";
+      if (key === "content") return typeof value !== "string";
+      return false;
+    })
+    .map(
+      ([key, _value]) =>
+        [key, keyTypes[key as keyof typeof keyTypes]] as [string, string],
+    );
+  if (missingKeys.length > 0 || extraKeys.length > 0 || badValues.length > 0) {
+    throw new BadDataIssues(missingKeys, extraKeys, badValues);
+  }
+  return comment as Pick<Comment, "author" | "content">;
+};
+
+enum ErrorType {
+  BadData,
+  MalformedID,
+  NotFound,
+  CNotFound,
+  InvalidQuery,
+}
+
+class PostError extends Error {
+  status: number;
+  constructor(type: ErrorType) {
+    let msg: string;
+    let st: number;
+    switch (type) {
+      case ErrorType.BadData:
+        msg = "Bad data";
+        st = 400;
+        break;
+      case ErrorType.NotFound:
+        msg = "Post not found";
+        st = 404;
+        break;
+      case ErrorType.MalformedID:
+        msg = "Malformed ID (should be a UUIDv7)";
+        st = 400;
+        break;
+      case ErrorType.CNotFound:
+        msg = "Comment not found";
+        st = 404;
+        break;
+      case ErrorType.InvalidQuery:
+        msg = "Invalid query";
+        st = 400;
+        break;
+      default:
+        msg = "Unknown error";
+        st = 500;
+    }
+    super(msg);
+    this.name = "PostError";
+    this.status = st;
+  }
+}
+
+const errorHandler = (
+  err: Error,
+  _req: Request,
+  res: Response,
+  _next: NextFunction,
+) => {
+  if (err instanceof PostError) {
+    let msg = err.message.replace("{{id}}", res.locals.id ?? "");
+
+    let obj: Map<string, any> = new Map<string, any>([
+      ["error", `${err.name}: ${msg}`],
+    ]);
+
+    if (res.locals.bdi) {
+      if (res.locals.bdi.missingKeys.length > 0) {
+        obj.set("missingKeys", res.locals.bdi.missingKeys);
+      }
+      if (res.locals.bdi.extraKeys.length > 0) {
+        obj.set("extraKeys", res.locals.bdi.extraKeys);
+      }
+      if (res.locals.bdi.badValues.length > 0) {
+        obj.set("badValues", res.locals.bdi.badValues);
+      }
+    }
+
+    res.status(err.status).json(Object.fromEntries(obj.entries()));
+  } else {
+    console.error(err.stack);
+    res.status(500).json({ error: "Internal Server Error" });
+  }
+};
+
+const router = express.Router();
+
+router.use((req, _res, next) => {
+  console.log(`Recieved ${req.method} request to ${req.url}`);
+  next();
+});
+
+router.get("/", async (_req, res) => {
+  const posts = await getPosts();
+  res.json(posts);
+});
+
+router.post("/", async (req, res) => {
+  try {
+    const details = validateUpdate(req.body);
+    const post: Post = {
+      id: Bun.randomUUIDv7(),
+      publicationDate: Date.now(),
+      likes: 0,
+      comments: [],
+      readTime: Math.ceil(details.content.length / 200),
+      ...details,
+    };
+    await updatePost(post);
+    res.json(post);
+  } catch (err) {
+    if (err instanceof BadDataIssues) {
+      res.locals.bdi = err;
+      throw new PostError(ErrorType.BadData);
+    } else {
+      throw err;
+    }
+  }
+});
+
+router.put("/:id", async (req, res) => {
+  res.locals.id = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) => p.id === res.locals.id);
+  if (!post) throw new PostError(ErrorType.NotFound);
+  try {
+    const details = validateUpdate(req.body);
+    post.title = details.title;
+    post.author = details.author;
+    post.content = details.content;
+    post.readTime = Math.ceil(details.content.length / 200);
+    await updatePost(post);
+    res.json(post);
+  } catch (err) {
+    if (err instanceof BadDataIssues) {
+      res.locals.bdi = err;
+      throw new PostError(ErrorType.BadData);
+    } else {
+      throw err;
+    }
+  }
+});
+
+router.delete("/:id", async (req, res) => {
+  res.locals.id = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) => p.id === res.locals.id);
+  if (!post) throw new PostError(ErrorType.NotFound);
+  await deletePost(res.locals.id);
+  res.json(post);
+});
+
+router.post("/:id/like", async (req, res) => {
+  res.locals.id = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) => p.id === res.locals.id);
+  if (!post) throw new PostError(ErrorType.NotFound);
+  post.likes++;
+  await updatePost(post);
+  res.json({ likes: post.likes });
+});
+
+router.post("/:id/comment", async (req, res) => {
+  res.locals.id = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) => p.id === res.locals.id);
+  if (!post) throw new PostError(ErrorType.NotFound);
+  try {
+    const details = validateComment(req.body);
+    const comment: Comment = {
+      id: Bun.randomUUIDv7(),
+      ...details,
+    };
+    post.comments.push(comment);
+    await updatePost(post);
+    res.json(post);
+  } catch (err) {
+    if (err instanceof BadDataIssues) {
+      res.locals.bdi = err;
+      throw new PostError(ErrorType.BadData);
+    } else {
+      throw err;
+    }
+  }
+});
+
+router.get("/:id/comments", async (req, res) => {
+  res.locals.id = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) => p.id === res.locals.id);
+  if (!post) throw new PostError(ErrorType.NotFound);
+  res.json(post.comments);
+});
+
+router.put("/comments/:id", async (req, res) => {
+  res.locals.cid = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) =>
+    p.comments.find((c) => c.id === res.locals.id),
+  );
+  if (!post) throw new PostError(ErrorType.CNotFound);
+  const comment = post.comments.find((c) => c.id === res.locals.id);
+  if (!comment) throw new PostError(ErrorType.CNotFound);
+  try {
+    const details = validateComment(req.body);
+    Object.assign(comment, details);
+    await updatePost(post);
+    res.json(comment);
+  } catch (err) {
+    if (err instanceof BadDataIssues) {
+      res.locals.bdi = err;
+      throw new PostError(ErrorType.BadData);
+    } else {
+      throw err;
+    }
+  }
+});
+
+router.delete("/comments/:id", async (req, res) => {
+  res.locals.cid = req.params.id;
+  if (!uuidv7.test(res.locals.id)) {
+    throw new PostError(ErrorType.MalformedID);
+  }
+  const posts = await getPosts();
+  const post = posts.find((p) =>
+    p.comments.find((c) => c.id === res.locals.id),
+  );
+  if (!post) throw new PostError(ErrorType.CNotFound);
+  const comment = post.comments.find((c) => c.id === res.locals.id);
+  if (!comment) throw new PostError(ErrorType.CNotFound);
+  post.comments = post.comments.filter((c) => c.id !== res.locals.id);
+  await updatePost(post);
+  res.json(comment);
+});
+
+router.get("/search", async (req, res) => {
+  const query = req.query.q?.toString();
+  if (!query) {
+    throw new PostError(ErrorType.InvalidQuery);
+  }
+  const posts = await getPosts();
+
+  const filteredPosts = posts.filter((post) => {
+    const titleMatch = post.title.includes(query);
+    const contentMatch = post.content.includes(query);
+    return titleMatch && contentMatch;
+  });
+
+  res.json(filteredPosts);
+});
+
+router.get("/filter", async (req, res) => {
+  const filter = req.query as Partial<{ author: string; tag: string }>;
+  if (!filter) {
+    throw new PostError(ErrorType.InvalidQuery);
+  }
+  const posts = await getPosts();
+
+  const filteredPosts = posts.filter((post) => {
+    const authorMatch = filter.author
+      ? post.author.includes(filter.author)
+      : true;
+    const tagsMatch = filter.tag
+      ? post.tags.some((tag) => tag === filter.tag)
+      : true;
+
+    return authorMatch && tagsMatch;
+  });
+
+  res.json(filteredPosts);
+});
+
+router.use(errorHandler);
+
+export default router;
-- 
2.51.2