:(

Signed-off-by: roxwize <rae@roxwize.xyz>

routes/admin.ts

@@ -36,7 +36,7 @@ export default function (app: Express, db: NodePgDatabase) {
         expiresString: now.to(dayjs(e.expires))
       };
     });
-    render(db, "admin", "Admin Panel", res, req, { codes });
+    render(db, "admin", "admin panel", res, req, { codes });
   });
 
   app.post("/codes/delete", async (req, res) => {

routes/login.ts

@@ -13,7 +13,7 @@ export default function(app: Express, db: NodePgDatabase) {
       res.redirect("/");
       return;
     }
-    render(db, "register", "Sign up", res, req);
+    render(db, "register", "sign up", res, req);
   });
   app.post("/register", async (req, res) => {
     if (req.session["loggedIn"]) {
@@ -49,22 +49,6 @@ export default function(app: Express, db: NodePgDatabase) {
       res.redirect("/register");
       return;
     }
-    
-    // invite code checking
-    const code = (await db.select({ expires: inviteCodes.expires, confers: inviteCodes.confers }).from(inviteCodes).where(eq(inviteCodes.token, req.body.referral)).limit(1))[0];
-    if (!code) {
-      req.flash("error", "Invalid invite code! Make sure you pasted it in correctly WITH the hyphens.");
-      res.redirect("/register");
-      return;
-    }
-    const expiration = code.expires.getTime();
-    if (expiration > 0 && Date.now() >= expiration) {
-      req.flash("error", "That code is expired.");
-      res.redirect("/register");
-      return;
-    }
-    // we're verified now so get that dumb fucker out of the database
-    await db.delete(inviteCodes).where(eq(inviteCodes.token, req.body.referral));
 
     // field conflicts
     if (
@@ -84,6 +68,22 @@ export default function(app: Express, db: NodePgDatabase) {
       res.redirect("/register");
       return;
     }
+    
+    // invite code checking
+    const code = (await db.select({ expires: inviteCodes.expires, confers: inviteCodes.confers }).from(inviteCodes).where(eq(inviteCodes.token, req.body.referral)).limit(1))[0];
+    if (!code) {
+      req.flash("error", "Invalid invite code! Make sure you pasted it in correctly WITH the hyphens.");
+      res.redirect("/register");
+      return;
+    }
+    const expiration = code.expires.getTime();
+    if (expiration > 0 && Date.now() >= expiration) {
+      req.flash("error", "That code is expired.");
+      res.redirect("/register");
+      return;
+    }
+    // we're verified now so get that dumb fucker out of the database
+    await db.delete(inviteCodes).where(eq(inviteCodes.token, req.body.referral));
 
     const hash = await bcrypt.hash(req.body.pass, 10);
     const { uid } = (
@@ -117,7 +117,7 @@ export default function(app: Express, db: NodePgDatabase) {
       res.redirect("/");
       return;
     }
-    render(db, "login", "Log in", res, req);
+    render(db, "login", "log in", res, req);
   });
   app.post("/login", async (req, res) => {
     if (req.session["loggedIn"]) {

routes/updates.ts

@@ -1,219 +1,239 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { Express } from "express";
 import {
-  follows,
-  inviteCodes,
-  journalEntries,
-  profiles,
-  updates,
-  users
+    follows,
+    inviteCodes,
+    journalEntries,
+    profiles,
+    updates,
+    users
 } from "../db/schema.js";
 import { and, count, desc, eq, sql } from "drizzle-orm";
 import dayjs from "dayjs";
-import { getMoods, render } from "./util.js";
+import { getMoods, render, render404 } from "./util.js";
 
 export default async function (app: Express, db: NodePgDatabase) {
-  const { moods, moodsSorted } = await getMoods();
+    const { moods, moodsSorted } = await getMoods();
 
-  // DASHBOARD
-  app.get("/dashboard", async (req, res) => {
-    if (!req.session["loggedIn"]) {
-      res.redirect("/login");
-      return;
-    }
-    const user = (
-      await db
-        .select({
-          name: users.name,
-          bio: profiles.bio,
-          website: profiles.website //! validate this
-        })
-        .from(users)
-        .where(eq(users.name, req.session["user"]))
-        .leftJoin(profiles, eq(users.id, profiles.user))
-    )[0];
-
-    const now = dayjs();
-    const moodHistory = (
-      await db
-        .select({ mood: updates.mood, date: updates.date })
-        .from(updates)
-        .where(eq(updates.user, req.session["uid"]))
-        .orderBy(desc(updates.date))
-        .limit(10)
-    ).map((e) => {
-      return { mood: moods[e.mood], date: now.to(dayjs(e.date)) };
-    });
-
-    const recentUpdates = (
-      await db
-        .select({
-          user: users.name,
-          mood: updates.mood,
-          desc: updates.description,
-          date: updates.date
-        })
-        .from(updates)
-        .innerJoin(
-          follows,
-          and(
-            eq(follows.userId, updates.user),
-            eq(follows.followerId, req.session["uid"])
-          )
-        )
-        .leftJoin(users, eq(updates.user, users.id))
-        .orderBy(desc(updates.date))
-        .limit(25)
-    ).map((e) => {
-      return {
-        user: e.user,
-        mood: moods[e.mood],
-        desc: e.desc,
-        date: now.to(dayjs(e.date))
-      };
-    });
-
-    // user invite codes
-    const codes = (await db
-      .select({ token: inviteCodes.token, expires: inviteCodes.expires })
-      .from(inviteCodes)
-      .where(eq(inviteCodes.user, req.session["uid"]))).map((e) => {
-        return {
-          token: e.token,
-          expires: now.to(dayjs(e.expires || 0))
+    // DASHBOARD
+    app.get("/dashboard", async (req, res) => {
+        if (!req.session["loggedIn"]) {
+            res.redirect("/login");
+            return;
         }
-      });
-    const { codesUsed } = (
-      await db
-        .select({ codesUsed: count() })
-        .from(inviteCodes)
-        .where(
-          and(
-            eq(inviteCodes.user, req.session["uid"]),
-            eq(
-              sql`extract(month from granted)`,
-              sql`extract(month from current_date)`
-            )
-          )
-        )
-    )[0];
+        const user = (
+            await db
+                .select({
+                    name: users.name,
+                    bio: profiles.bio,
+                    website: profiles.website //! validate this
+                })
+                .from(users)
+                .where(eq(users.name, req.session["user"]))
+                .leftJoin(profiles, eq(users.id, profiles.user))
+        )[0];
 
-    render(db, "dashboard", "Dashboard", res, req, {
-      user,
-      moods,
-      moodsSorted,
-      moodHistory,
-      recentUpdates,
-      codes,
-      codesUsed,
-      feed: []
+        const now = dayjs();
+        const moodHistory = (
+            await db
+                .select({ mood: updates.mood, date: updates.date })
+                .from(updates)
+                .where(eq(updates.user, req.session["uid"]))
+                .orderBy(desc(updates.date))
+                .limit(10)
+        ).map((e) => {
+            return { mood: moods[e.mood], date: now.to(dayjs(e.date)) };
+        });
+
+        const recentUpdates = (
+            await db
+                .select({
+                    user: users.name,
+                    mood: updates.mood,
+                    desc: updates.description,
+                    date: updates.date
+                })
+                .from(updates)
+                .innerJoin(
+                    follows,
+                    and(
+                        eq(follows.userId, updates.user),
+                        eq(follows.followerId, req.session["uid"])
+                    )
+                )
+                .leftJoin(users, eq(updates.user, users.id))
+                .orderBy(desc(updates.date))
+                .limit(25)
+        ).map((e) => {
+            return {
+                user: e.user,
+                mood: moods[e.mood],
+                desc: e.desc,
+                date: e.date,
+                relativeDate: now.to(dayjs(e.date))
+            };
+        });
+
+        // user invite codes
+        const codes = (
+            await db
+                .select({
+                    token: inviteCodes.token,
+                    expires: inviteCodes.expires
+                })
+                .from(inviteCodes)
+                .where(eq(inviteCodes.user, req.session["uid"]))
+        ).map((e) => {
+            return {
+                token: e.token,
+                expires: now.to(dayjs(e.expires || 0))
+            };
+        });
+        const { codesUsed } = (
+            await db
+                .select({ codesUsed: count() })
+                .from(inviteCodes)
+                .where(
+                    and(
+                        eq(inviteCodes.user, req.session["uid"]),
+                        eq(
+                            sql`extract(month from granted)`,
+                            sql`extract(month from current_date)`
+                        )
+                    )
+                )
+        )[0];
+
+        render(db, "dashboard", "dashboard", res, req, {
+            user,
+            moods,
+            moodsSorted,
+            moodHistory,
+            recentUpdates,
+            codes,
+            codesUsed,
+            feed: []
+        });
     });
-  });
-  app.post("/update/mood", async (req, res) => {
-    if (!req.session["loggedIn"]) {
-      res.redirect("/login");
-      return;
-    }
-    const moodIndex = moods.indexOf(req.body.mood.trim());
-    if (moodIndex === -1) {
-      req.flash(
-        "error",
-        "That mood doesn't exist in the database, WTF are you trying to do??"
-      );
-      res.redirect("/dashboard");
-      return;
-    }
-    if (req.body.desc.length > 512) {
-      req.flash(
-        "error",
-        "Mood description can't be longer than 512 characters"
-      );
-      res.redirect("/dashboard");
-    }
+    app.post("/update/mood", async (req, res) => {
+        if (!req.session["loggedIn"]) {
+            res.redirect("/login");
+            return;
+        }
+        const moodIndex = moods.indexOf(req.body.mood.trim());
+        if (moodIndex === -1) {
+            req.flash(
+                "error",
+                "That mood doesn't exist in the database, WTF are you trying to do??"
+            );
+            res.redirect("/dashboard");
+            return;
+        }
+        if (req.body.desc.length > 512) {
+            req.flash(
+                "error",
+                "Mood description can't be longer than 512 characters"
+            );
+            res.redirect("/dashboard");
+        }
 
-    await db
-      .insert(updates)
-      // @ts-expect-error
-      .values({
-        user: req.session["uid"],
-        mood: moodIndex,
-        description: req.body.desc,
-        date: new Date(Date.now())
-      });
-    req.flash("success", "Mood updated!");
-    res.redirect("/dashboard");
-  });
+        await db
+            .insert(updates)
+            // @ts-expect-error
+            .values({
+                user: req.session["uid"],
+                mood: moodIndex,
+                description: req.body.desc,
+                date: new Date(Date.now())
+            });
+        req.flash("success", "Mood updated!");
+        res.redirect("/dashboard");
+    });
 
-  // JOURNAL
-  app.get("/journal", async (req, res) => {
-    render(db, "journal", "Journal", res, req);
-  });
-  app.get("/journal/:id", async (req, res) => {
-    const entry = (
-      await db
-        .select({
-          uname: users.name,
-          content: journalEntries.entry,
-          date: journalEntries.date
-        })
-        .from(journalEntries)
-        .where(eq(journalEntries.id, parseInt(req.params.id)))
-        .leftJoin(users, eq(journalEntries.user, users.id))
-    )[0];
-    if (!entry) {
-      //! TODO write a 404 page
-      res.statusCode = 404;
-      res.write("404 not found?? :(");
-      return;
-    }
-    render(db, "journal_view", "Journal Entry", res, req, { entry });
-  });
-  app.post("/update/journal", async (req, res) => {
-    if (!req.session["loggedIn"]) {
-      res.redirect("/login");
-      return;
-    }
-    if (req.body.description.length > 4096) {
-      req.flash("error", "Entry too long!");
-      res.redirect("/journal");
-      return;
-    }
+    // JOURNAL
+    app.get("/journal", async (req, res) => {
+        render(db, "journal", "your journal", res, req);
+    });
+    app.get("/journal/:id", async (req, res) => {
+        const entry = (
+            await db
+                .select({
+                    uname: users.name,
+                    title: journalEntries.title,
+                    content: journalEntries.entry,
+                    date: journalEntries.date
+                })
+                .from(journalEntries)
+                .where(eq(journalEntries.id, parseInt(req.params.id)))
+                .leftJoin(users, eq(journalEntries.user, users.id))
+        )[0];
+        if (!entry) {
+            render404(db, res, req);
+            return;
+        }
 
-    const moodChange = parseInt(req.body.moodDelta);
-    const visibility = parseInt(req.body.visibility);
-    if (isNaN(moodChange) || isNaN(visibility)) {
-      req.flash("error", "One of the values was improperly specified.");
-      res.redirect("/journal");
-      return;
-    }
+        const entryTimestamp = dayjs(entry.date).fromNow();
+        render(db, "journal_view", entry.title, res, req, {
+            entry,
+            entryTimestamp
+        });
+    });
+    app.post("/update/journal", async (req, res) => {
+        if (!req.session["loggedIn"]) {
+            res.redirect("/login");
+            return;
+        }
+        if (req.body.title.length > 64) {
+            req.flash("error", "Title too long!");
+            res.redirect("/journal");
+            return;
+        }
+        if (req.body.description.length > 4096) {
+            req.flash("error", "Entry too long!");
+            res.redirect("/journal");
+            return;
+        }
 
-    let id: number;
-    try {
-      const entry = await db
-        .insert(journalEntries)
-        // @ts-expect-error
-        .values({
-          user: req.session["uid"],
-          moodChange,
-          visibility,
-          entry: req.body.description,
-          date: new Date(Date.now())
-        })
-        .returning({ id: journalEntries.id });
-      id = entry[0].id;
-    } catch (err) {
-      req.flash(
-        "error",
-        "Failed to create your entry. Try again later or send these logs to roxwize so she can know what's up:<br><br>" +
-          err
-      );
-      res.redirect("/journal");
-      return;
-    }
-    req.flash(
-      "success",
-      `Your journal entry is now available as <a href="/journal/${id}">#${id}</a>!`
-    );
-    res.redirect("/journal");
-  });
+        const moodChange = parseInt(req.body.moodDelta);
+        const visibility = parseInt(req.body.visibility);
+        if (isNaN(moodChange) || isNaN(visibility)) {
+            req.flash("error", "One of the values was improperly specified.");
+            res.redirect("/journal");
+            return;
+        }
+
+        let id: number;
+        try {
+            const entry = await db
+                .insert(journalEntries)
+                // @ts-expect-error
+                .values({
+                    user: req.session["uid"],
+                    moodChange,
+                    visibility,
+                    title: req.body.title,
+                    entry: req.body.description
+                        .replaceAll("&", "&amp;")
+                        .replaceAll("<", "&lt;")
+                        .replaceAll(">", "&gt;")
+                        .replaceAll("\n", "<br>"),
+                    date: new Date(Date.now())
+                })
+                .returning({ id: journalEntries.id });
+            id = entry[0].id;
+        } catch (err) {
+            req.flash(
+                "error",
+                "Failed to create your entry. Try again later or send these logs to roxwize so she can know what's up:<br><br>" +
+                    err
+            );
+            res.redirect("/journal");
+            return;
+        }
+        req.flash(
+            "success",
+            `Your journal entry is now available as <a href="/journal/${id}">#${id}</a>!`
+        );
+        res.redirect("/journal");
+    });
 }

routes/users.ts

@@ -1,168 +1,216 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { Express } from "express";
-import { follows, profiles, updates, users } from "../db/schema.js";
+import {
+    follows,
+    journalEntries,
+    profiles,
+    updates,
+    users
+} from "../db/schema.js";
 import { and, desc, eq } from "drizzle-orm";
-import { getMoods, render, UserStatus } from "./util.js";
+import { getMoods, render, render404, UserStatus } from "./util.js";
 import { PgColumn } from "drizzle-orm/pg-core";
 import dayjs from "dayjs";
 
 export default async function (app: Express, db: NodePgDatabase) {
-  const { moods } = await getMoods();
-  app.get("/users/:user", async (req, res) => {
-    const isSelf = req.params.user === req.session["user"];
+    const { moods } = await getMoods();
+    app.get("/users/:user", async (req, res) => {
+        const isSelf = req.params.user === req.session["user"];
 
-    const user = (
-      await db
-        .select({
-          id: users.id,
-          name: users.name,
-          bio: profiles.bio,
-          website: profiles.website
-        })
-        .from(users)
-        .where(eq(users.name, req.params.user))
-        .leftJoin(profiles, eq(profiles.user, users.id))
-    )[0];
-    if (!user) {
-      req.flash("error", `User ${req.params.user} does not exist`);
-      res.redirect("/");
-      return;
-    }
+        const user: {
+            id: number;
+            name: string;
+            registered: Date;
+            relativeRegistered?: string;
+            bio: string;
+            website: string;
+        } = (
+            await db
+                .select({
+                    id: users.id,
+                    name: users.name,
+                    registered: users.registered,
+                    bio: profiles.bio,
+                    website: profiles.website
+                })
+                .from(users)
+                .where(eq(users.name, req.params.user))
+                .leftJoin(profiles, eq(profiles.user, users.id))
+        )[0];
+        if (!user) {
+            render404(db, res, req);
+            return;
+        }
+        user.relativeRegistered = dayjs(user.registered).fromNow();
 
-    // follows
-    const isFollowing = !!(
-      await db
-        .select()
-        .from(follows)
-        .where(
-          and(
-            eq(follows.followerId, req.session["uid"]),
-            eq(follows.userId, user.id)
-          )
-        )
-        .limit(1)
-    )[0];
+        // follows
+        const isFollowing = !!(
+            await db
+                .select()
+                .from(follows)
+                .where(
+                    and(
+                        eq(follows.followerId, req.session["uid"]),
+                        eq(follows.userId, user.id)
+                    )
+                )
+                .limit(1)
+        )[0];
 
-    // mood
-    let moodSelection: { [k: string]: PgColumn } = {
-      desc: updates.description,
-      date: updates.date
-    };
-    if (!isSelf) moodSelection.mood = updates.mood;
-    const userMood: { [k: string]: string | number | Date } = (
-      await db
-        .select(moodSelection)
-        .from(updates)
-        .where(eq(updates.user, user.id))
-        .orderBy(desc(updates.date))
-        .limit(1)
-    )[0];
+        // mood
+        let moodSelection: { [k: string]: PgColumn } = {
+            desc: updates.description,
+            date: updates.date
+        };
+        if (!isSelf) moodSelection.mood = updates.mood;
+        const userMood: { [k: string]: string | number | Date } = (
+            await db
+                .select(moodSelection)
+                .from(updates)
+                .where(eq(updates.user, user.id))
+                .orderBy(desc(updates.date))
+                .limit(1)
+        )[0];
 
-    // feed
-    const now = dayjs();
-    const userMoodFeed = (await db
-      .select({
-        mood: updates.mood,
-        date: updates.date,
-        desc: updates.description
-      })
-      .from(updates)
-      .where(eq(updates.user, user.id))).map((e) => {
-        return { user: user.name, mood: moods[e.mood], date: now.to(dayjs(e.date)), desc: e.desc }
-      });
+        // journal entries
+        const now = dayjs();
+        const userJournalEntries = (
+            await db
+                .select({
+                    id: journalEntries.id,
+                    title: journalEntries.title,
+                    date: journalEntries.date
+                })
+                .from(journalEntries)
+                .where(eq(journalEntries.user, user.id))
+                .orderBy(desc(journalEntries.date))
+                .limit(5)
+        ).map((e) => {
+            return {
+                id: e.id,
+                title: e.title,
+                date: e.date,
+                relativeDate: now.to(e.date)
+            };
+        });
 
-    if (!isSelf) {
-      userMood.mood = moods[userMood.mood as number];
-    }
+        // feed
+        const userMoodFeed = (
+            await db
+                .select({
+                    mood: updates.mood,
+                    date: updates.date,
+                    desc: updates.description
+                })
+                .from(updates)
+                .where(eq(updates.user, user.id))
+                .orderBy(desc(updates.date))
+        ).map((e) => {
+            return {
+                user: user.name,
+                mood: moods[e.mood],
+                date: e.date,
+                relativeDate: now.to(dayjs(e.date)),
+                desc: e.desc
+            };
+        });
 
-    render(db, "user", `${req.params.user}'s Profile`, res, req, {
-      user,
-      isSelf,
-      userMood,
-      userMoodFeed,
-      isFollowing
+        if (!isSelf) {
+            userMood.mood = moods[userMood.mood as number];
+        }
+
+        render(db, "user", `${req.params.user}'s profile`, res, req, {
+            user,
+            isSelf,
+            userMood,
+            userMoodFeed,
+            userJournalEntries,
+            isFollowing
+        });
     });
-  });
-  app.post("/users/:user/edit", async (req, res) => {
-    if (!req.session["loggedIn"]) {
-      res.redirect("/login");
-      return;
-    }
-    const { uname } = (
-      await db
-        .select({ uname: users.name })
-        .from(users)
-        .where(eq(users.name, req.params.user))
-    )[0];
-    if ((uname || "") !== req.session["user"] && !(req.session["status"] & UserStatus.MODERATOR)) {
-      res.redirect("back");
-      return;
-    }
+    app.post("/users/:user/edit", async (req, res) => {
+        if (!req.session["loggedIn"]) {
+            res.redirect("/login");
+            return;
+        }
+        const { uname } = (
+            await db
+                .select({ uname: users.name })
+                .from(users)
+                .where(eq(users.name, req.params.user))
+        )[0];
+        if (
+            (uname || "") !== req.session["user"] &&
+            !(req.session["status"] & UserStatus.MODERATOR)
+        ) {
+            res.redirect("back");
+            return;
+        }
 
-    await db //! no sanitization here either BROOOOOOO
-      .update(profiles)
-      .set({
-        // @ts-expect-error
-        bio: req.body.bio,
-        website: req.body.website
-      })
-      .where(eq(profiles.user, req.session["uid"]));
-    req.flash("success", "Profile updated!");
-    res.redirect("/dashboard");
-  });
-  app.post("/users/:user/follow", async (req, res) => {
-    if (!req.session["loggedIn"]) {
-      res.redirect("/login");
-      return;
-    }
-    if (req.session["user"] === req.params.user) {
-      req.flash("error", "Can't Follow Yourself Dummy");
-      res.redirect(`/users/${req.params.user}`);
-      return;
-    }
+        await db //! no sanitization here either BROOOOOOO
+            .update(profiles)
+            .set({
+                // @ts-expect-error
+                bio: req.body.bio,
+                website: req.body.website
+            })
+            .where(eq(profiles.user, req.session["uid"]));
+        req.flash("success", "Profile updated!");
+        res.redirect("/dashboard");
+    });
+    app.post("/users/:user/follow", async (req, res) => {
+        if (!req.session["loggedIn"]) {
+            res.redirect("/login");
+            return;
+        }
+        if (req.session["user"] === req.params.user) {
+            req.flash("error", "Can't Follow Yourself Dummy");
+            res.redirect(`/users/${req.params.user}`);
+            return;
+        }
 
-    const { uid } = (
-      await db
-        .select({ uid: users.id })
-        .from(users)
-        .where(eq(users.name, req.params.user))
-    )[0];
-    if (!uid) {
-      req.flash(
-        "error",
-        "It looks like you're trying to follow a user that doesn't exist anymore."
-      );
-      res.redirect("/");
-      return;
-    }
-    const isFollowing = !!(
-      await db
-        .select()
-        .from(follows)
-        .where(
-          and(
-            eq(follows.followerId, req.session["uid"]),
-            eq(follows.userId, uid)
-          )
-        )
-        .limit(1)
-    )[0];
-    if (isFollowing) {
-      // unfollow
-      await db
-        .delete(follows)
-        .where(
-          and(
-            eq(follows.followerId, req.session["uid"]),
-            eq(follows.userId, uid)
-          )
-        );
-    } else {
-      await db.insert(follows).values({
-        userId: uid,
-        followerId: req.session["uid"]
-      });
-    }
-    res.redirect(`/users/${req.params.user}`);
-  });
+        const { uid } = (
+            await db
+                .select({ uid: users.id })
+                .from(users)
+                .where(eq(users.name, req.params.user))
+        )[0];
+        if (!uid) {
+            req.flash(
+                "error",
+                "It looks like you're trying to follow a user that doesn't exist anymore."
+            );
+            res.redirect("/");
+            return;
+        }
+        const isFollowing = !!(
+            await db
+                .select()
+                .from(follows)
+                .where(
+                    and(
+                        eq(follows.followerId, req.session["uid"]),
+                        eq(follows.userId, uid)
+                    )
+                )
+                .limit(1)
+        )[0];
+        if (isFollowing) {
+            // unfollow
+            await db
+                .delete(follows)
+                .where(
+                    and(
+                        eq(follows.followerId, req.session["uid"]),
+                        eq(follows.userId, uid)
+                    )
+                );
+        } else {
+            await db.insert(follows).values({
+                userId: uid,
+                followerId: req.session["uid"]
+            });
+        }
+        res.redirect(`/users/${req.params.user}`);
+    });
 }

routes/util.ts

@@ -5,92 +5,113 @@ import { count, desc, eq } from "drizzle-orm";
 import fs from "node:fs/promises";
 
 export enum UserStatus {
-  MODERATOR = 0b001,
-  BANNED = 0b010,
-  TRUSTED = 0b100
-};
+    MODERATOR = 0b001,
+    BANNED = 0b010,
+    TRUSTED = 0b100
+}
 
 const nonceChars =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890-_";
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890-_";
 let nonce: string;
 export function setNonce() {
-  nonce = "";
-  for (let i = 0; i < 32; i++)
-    nonce += nonceChars[Math.floor(Math.random() * nonceChars.length)];
-  return nonce;
+    nonce = "";
+    for (let i = 0; i < 32; i++)
+        nonce += nonceChars[Math.floor(Math.random() * nonceChars.length)];
+    return nonce;
 }
 export function getNonce() {
-  if (!nonce)
-    throw new Error("Nonce doesn't exist");
-  return nonce;
+    if (!nonce) throw new Error("Nonce doesn't exist");
+    return nonce;
 }
 
 let moods: string[], moodsSorted: string[];
 export async function getMoods() {
-  if (!moods)
-    moods = (await fs.readFile("./static/moods.txt"))
-      .toString("utf-8")
-      .split(";");
-  if (!moodsSorted) moodsSorted = Array.from(moods).sort();
-  return { moods, moodsSorted };
+    if (!moods)
+        moods = (await fs.readFile("./static/moods.txt"))
+            .toString("utf-8")
+            .split(";");
+    if (!moodsSorted) moodsSorted = Array.from(moods).sort();
+    return { moods, moodsSorted };
 }
 
 export async function render(
-  db: NodePgDatabase,
-  page: string,
-  title: string,
-  res: Response,
-  req: Request,
-  stuff?: Object
+    db: NodePgDatabase,
+    page: string,
+    title: string,
+    res: Response,
+    req: Request,
+    stuff?: Object
 ) {
-  //? maybe you should cache this and save the current mood to the session until it's changed
-  const { moods } = await getMoods();
-  let currentMood: string;
-  if (req.session["loggedIn"]) {
-    const update = (
-      await db
-        .select({ mood: updates.mood })
-        .from(updates)
-        .where(eq(updates.user, req.session["uid"]))
-        .orderBy(desc(updates.date))
-        .limit(1)
-    )[0];
-    currentMood = moods[update?.mood];
-  }
-
-  const o = {
-    title,
-    session: req.session,
-    flashes: req.flash(),
-    moods,
-    currentMood,
-    nonce
-  };
-  res.render(page, { ...o, ...stuff });
-}
-
-const inviteCodeChars = "abcdefghijklmnopqrstuvwxyz0123456789"
-export async function createInviteCode(db: NodePgDatabase, user: number, expires: Date, confers = 0) {
-  let existingToken = 1, token: string;
-  while (existingToken) {
-    token = user.toString().padStart(4, "0") + "-"
-    for (let i = 0; i < 17; i++) {
-      if ((i + 1) % 6 === 0) {
-        token += "-";
-        continue;
-      }
-      token += inviteCodeChars[Math.floor(Math.random() * inviteCodeChars.length)];
+    //? maybe you should cache this and save the current mood to the session until it's changed
+    const { moods } = await getMoods();
+    let currentMood: string;
+    if (req.session["loggedIn"]) {
+        const update = (
+            await db
+                .select({ mood: updates.mood })
+                .from(updates)
+                .where(eq(updates.user, req.session["uid"]))
+                .orderBy(desc(updates.date))
+                .limit(1)
+        )[0];
+        currentMood = moods[update?.mood];
     }
-    existingToken = (await db.select({ value: count() }).from(inviteCodes).where(eq(inviteCodes.token, token)))[0].value;
-  }
 
-  //@ts-expect-error
-  await db.insert(inviteCodes).values({
-    token,
-    user: user || undefined,
-    granted: new Date(Date.now()),
-    expires,
-    confers
-  });
-  return token;
+    const o = {
+        title,
+        session: req.session,
+        flashes: req.flash(),
+        moods,
+        currentMood,
+        nonce
+    };
+    res.render(page, { ...o, ...stuff });
+}
+export async function render404(
+    db: NodePgDatabase,
+    res: Response,
+    req: Request
+) {
+    res.statusCode = 404;
+    render(db, "404", "not found", res, req);
+}
+
+const inviteCodeChars = "abcdefghijklmnopqrstuvwxyz0123456789";
+export async function createInviteCode(
+    db: NodePgDatabase,
+    user: number,
+    expires: Date,
+    confers = 0
+) {
+    let existingToken = 1,
+        token: string;
+    while (existingToken) {
+        token = user.toString().padStart(4, "0") + "-";
+        for (let i = 0; i < 17; i++) {
+            if ((i + 1) % 6 === 0) {
+                token += "-";
+                continue;
+            }
+            token +=
+                inviteCodeChars[
+                    Math.floor(Math.random() * inviteCodeChars.length)
+                ];
+        }
+        existingToken = (
+            await db
+                .select({ value: count() })
+                .from(inviteCodes)
+                .where(eq(inviteCodes.token, token))
+        )[0].value;
+    }
+
+    //@ts-expect-error
+    await db.insert(inviteCodes).values({
+        token,
+        user: user || undefined,
+        granted: new Date(Date.now()),
+        expires,
+        confers
+    });
+    return token;
 }