minor cleanup

mostly just improving middleware schemas when login mismatches occur

src/endpoints/account.tsx

···
 
   // Redirect to home
   c.header("HX-Redirect", "/");
-  return c.html("Success");
+  return c.text("");
 });
 
 account.post("/signup", verifyTurnstile, async (c: Context) => {

src/endpoints/post.tsx

···
 import { corsHelperMiddleware } from "../middleware/corsHelper";
 import {
   Bindings, CreateObjectResponse, CreatePostQueryResponse,
-  DeleteResponse,
-  EmbedDataType, LooseObj
+  DeleteResponse, EmbedDataType, LooseObj
 } from "../types";
 import {
   createPost, createRepost,
···
 
 post.use(secureHeaders());
 post.use(corsHelperMiddleware);
+post.use(authMiddleware);
 
 // Create media upload
-post.post("/upload", authMiddleware, async (c: Context) => {
+post.post("/upload", async (c: Context) => {
   const formData = await c.req.parseBody();
   const fileUploadResponse = await uploadFileR2(c, formData['file'], c.get("userId"));
   if (fileUploadResponse.success === false)
···
 });
 
 // Delete an upload
-post.delete("/upload", authMiddleware, async (c: Context) => {
+post.delete("/upload", async (c: Context) => {
   const body = await c.req.json();
 
   // Validate that this is a legitimate key
···
 });
 
 // Create post
-post.post("/create", authMiddleware, async (c: Context) => {
+post.post("/create", async (c: Context) => {
   const body = await c.req.json();
   const response: CreatePostQueryResponse = await createPost(c, body);
   if (!response.ok) {
···
 });
 
 // Create repost
-post.post("/create/repost", authMiddleware, async (c: Context) => {
+post.post("/create/repost", async (c: Context) => {
   const body = await c.req.json();
   const response: CreateObjectResponse = await createRepost(c, body);
   if (!response.ok) {
···
 });
 
 // Get all posts
-post.all("/all", authMiddleware, async (c: Context) => {
+post.all("/all", async (c: Context) => {
   c.header("HX-Trigger-After-Swap", "timeSidebar");
   return c.html(
     <ScheduledPostList ctx={c} />
···
 });
 
 // Edit posts
-post.get("/edit/:id", authMiddleware, async (c: Context) => {
+post.get("/edit/:id", async (c: Context) => {
   const { id } = c.req.param();
   if (!isValid(id))
     return c.html(<></>, 400);
···
   return c.html(<></>, 400);
 });
 
-post.post("/edit/:id", authMiddleware, async (c: Context) => {
+post.post("/edit/:id", async (c: Context) => {
   const { id } = c.req.param();
   const swapErrEvents: string = "refreshPosts, scrollTop, scrollListTop";
   if (!isValid(id)) {
···
   return c.html(<b class="btn-error">Failed to process edit</b>, 400);
 });
 
-post.get("/edit/:id/cancel", authMiddleware, async (c: Context) => {
+post.get("/edit/:id/cancel", async (c: Context) => {
   const { id } = c.req.param();
   if (!isValid(id))
     return c.html(<></>, 400);
···
 });
 
 // delete a post
-post.delete("/delete/:id", authMiddleware, async (c: Context) => {
+post.delete("/delete/:id", async (c: Context) => {
   const { id } = c.req.param();
   if (isValid(id)) {
     const response: DeleteResponse = await deletePost(c, id);

src/endpoints/preview.tsx

···
 import isEmpty from "just-is-empty";
 import { ContextVariables } from "../auth";
 import { BSKY_IMG_MIME_TYPES } from "../limits";
-import { authMiddleware } from "../middleware/auth";
+import { hasAuth, pullAuthData } from "../middleware/auth";
 import { corsHelperMiddleware } from "../middleware/corsHelper";
 import { Bindings } from "../types";
 import { FileContentSchema } from "../validation/mediaSchema";
···
 preview.use(secureHeaders());
 preview.use(corsHelperMiddleware);
 
-preview.get("/file/:id", authMiddleware, async (c: Context) => {
+preview.get("/file/:id", pullAuthData, async (c: Context) => {
+  if (!hasAuth(c)) {
+    return c.redirect("/thumbs/missing.png");
+  }
+
   const { id } = c.req.param();
   const validation = FileContentSchema.safeParse({content: id});
   if (!validation.success) {

src/index.tsx

···
 import { admin } from "./endpoints/admin";
 import { post } from "./endpoints/post";
 import { preview } from "./endpoints/preview";
-import { authMiddleware } from "./middleware/auth";
 import { corsHelperMiddleware } from "./middleware/corsHelper";
 import { redirectToDashIfLogin } from "./middleware/redirectDash";
+import { redirectHomeIfLogout } from "./middleware/redirectHome";
 import Dashboard from "./pages/dashboard";
 import ForgotPassword from "./pages/forgot";
 import Homepage from "./pages/homepage";
···
 app.route("/preview", preview);
 
 // Dashboard route
-app.get("/dashboard", authMiddleware, (c) => c.html(<Dashboard c={c} />));
+app.get("/dashboard", redirectHomeIfLogout, (c) => c.html(<Dashboard c={c} />));
 
 // Login route
 app.get("/login", redirectToDashIfLogin, (c) => c.html(<Login />));

src/middleware/adminOnly.ts

···
     await next();
     return;
   }
-  return c.json({ error: "Unauthorized" }, 401);
+  return c.json({ ok: false, msg: "Unauthorized" }, 401);
 }
 
 export const authAdminOnlyMiddleware = every(authMiddleware, adminOnlyMiddleware);

src/middleware/auth.ts

···
     c.set("session", null);
   }
   await next();
-}
+};
+
 export async function requireAuth(c: Context, next: any) {
-  if (c.get("session") === null || c.get("userId") === null) {
-    return c.json({ error: "Unauthorized" }, 401);
+  if (!hasAuth(c)) {
+    return c.json({ ok: false, msg: "Unauthorized" }, 401);
   }
   await next();
+};
+
+export function hasAuth(c: Context) {
+  return (c.get("session") !== null && c.get("userId") !== null);
 }
 
 export const authMiddleware = every(pullAuthData, requireAuth);

src/middleware/redirectHome.ts

···
+import { Context } from "hono";
+import { every } from "hono/combine";
+import { hasAuth, pullAuthData } from "./auth";
+
+export async function goHomeIfLogout(c: Context, next: any) {
+  if (!hasAuth(c)) {
+    return c.redirect("/");
+  }
+  await next();
+}
+
+export const redirectHomeIfLogout = every(pullAuthData, goHomeIfLogout);