mipilin/routes/updates.ts

import { NodePgDatabase } from "drizzle-orm/node-postgres";
import { Express } from "express";
import {
  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";

export default async function (app: Express, db: NodePgDatabase) {
  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))
        }
      });
    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");
    }

    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;
    }

    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,
          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");
  });
}