add did/collection/rkey route and appropriate redirects

src/lib/errors.ts

···
 import { OAUTH_ROUTES, RateLimitError, UnauthorizedError } from "@bigmoves/bff";
 import { formatDuration, intervalToDuration } from "date-fns";
 
+function errorResponse(message: string, status: number): Response {
+  return new Response(message, {
+    status,
+    headers: { "Content-Type": "text/plain; charset=utf-8" },
+  });
+}
+
 export function onError(err: unknown): Response {
+  if (err instanceof BadRequestError) {
+    return errorResponse(err.message, 400);
+  }
+  if (err instanceof ServerError) {
+    return errorResponse(err.message, 500);
+  }
+  if (err instanceof NotFoundError) {
+    return errorResponse(err.message, 404);
+  }
   if (err instanceof UnauthorizedError) {
     const ctx = err.ctx;
     return ctx.redirect(OAUTH_ROUTES.loginPage);
···
       {
         status: 429,
         headers: {
-          ...err.retryAfter && { "Retry-After": err.retryAfter.toString() },
-          "Content-Type": "text/plain",
+          ...(err.retryAfter && { "Retry-After": err.retryAfter.toString() }),
+          "Content-Type": "text/plain; charset=utf-8",
         },
       },
     );
   }
-  return new Response("Internal Server Error", {
-    status: 500,
-  });
+  return errorResponse("Internal Server Error", 500);
+}
+
+export class NotFoundError extends Error {
+  constructor(message = "Not Found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+
+export const ServerError = class extends Error {
+  constructor(message = "Internal Server Error") {
+    super(message);
+    this.name = "ServerError";
+  }
+};
+
+export class BadRequestError extends Error {
+  constructor(message: string = "Bad Request") {
+    super(message);
+    this.name = "BadRequestError";
+  }
 }

src/lib/uploads.tsx

···
-import { Record as Photo } from "$lexicon/types/social/grain/photo.ts";
-import { BffMiddleware, route, RouteHandler } from "@bigmoves/bff";
-import { PhotoPreview } from "../components/PhotoPreview.tsx";
-import { photoThumb } from "./photo.ts";
-
-function uploadPhoto(): RouteHandler {
-  return async (req, _params, ctx) => {
-    const { did } = ctx.requireAuth();
-    ctx.rateLimit({
-      namespace: "upload",
-      points: 1,
-      limit: 50,
-      window: 24 * 60 * 60 * 1000, // 24 hours
-    });
-    if (!ctx.agent) {
-      return new Response("Agent has not been initialized", { status: 401 });
-    }
-    try {
-      const formData = await req.formData();
-      const file = formData.get("file") as File;
-      const width = Number(formData.get("width")) || undefined;
-      const height = Number(formData.get("height")) || undefined;
-      if (!file) {
-        return new Response("No file", { status: 400 });
-      }
-      // Check if file size exceeds 20MB limit
-      const maxSizeBytes = 20 * 1000 * 1000; // 20MB in bytes
-      if (file.size > maxSizeBytes) {
-        return new Response("File too large. Maximum size is 20MB", {
-          status: 400,
-        });
-      }
-      const blobResponse = await ctx.agent.uploadBlob(file);
-      const photoUri = await ctx.createRecord<Photo>("social.grain.photo", {
-        photo: blobResponse.data.blob,
-        aspectRatio: width && height
-          ? {
-            width,
-            height,
-          }
-          : undefined,
-        alt: "",
-        createdAt: new Date().toISOString(),
-      });
-      return ctx.html(
-        <PhotoPreview
-          src={photoThumb(did, blobResponse.data.blob.ref.toString())}
-          uri={photoUri}
-        />,
-      );
-    } catch (e) {
-      console.error("Error in uploadStart:", e);
-      return new Response("Internal Server Error", { status: 500 });
-    }
-  };
-}
-
-export function photoUploadRoutes(): BffMiddleware[] {
-  return [
-    route(
-      `/actions/photo/upload`,
-      ["POST"],
-      uploadPhoto(),
-    ),
-  ];
-}

src/main.tsx

···
 import { LoginPage } from "./components/LoginPage.tsx";
 import { PDS_HOST_URL } from "./env.ts";
 import { onError } from "./lib/errors.ts";
-import { photoUploadRoutes } from "./lib/uploads.tsx";
 import * as actionHandlers from "./routes/actions.tsx";
 import * as dialogHandlers from "./routes/dialogs.tsx";
 import { handler as exploreHandler } from "./routes/explore.tsx";
···
 import { handler as notificationsHandler } from "./routes/notifications.tsx";
 import { handler as onboardHandler } from "./routes/onboard.tsx";
 import { handler as profileHandler } from "./routes/profile.tsx";
+import { handler as recordHandler } from "./routes/record.tsx";
 import { handler as timelineHandler } from "./routes/timeline.tsx";
 import { handler as uploadHandler } from "./routes/upload.tsx";
 import { appStateMiddleware, type State } from "./state.ts";
···
       actionHandlers.gallerySort,
     ),
     route("/actions/get-blob", ["GET"], actionHandlers.getBlob),
-    ...photoUploadRoutes(),
+    route("/actions/photo/upload", ["POST"], actionHandlers.uploadPhoto),
+    route("/:did/:collection/:rkey", recordHandler),
   ],
 });

src/routes/actions.tsx

···
 import { FavoriteButton } from "../components/FavoriteButton.tsx";
 import { FollowButton } from "../components/FollowButton.tsx";
 import { PhotoButton } from "../components/PhotoButton.tsx";
+import { PhotoPreview } from "../components/PhotoPreview.tsx";
 import { PhotoSelectButton } from "../components/PhotoSelectButton.tsx";
 import { deleteGallery, getGallery, getGalleryFavs } from "../lib/gallery.ts";
-import { photoToView } from "../lib/photo.ts";
+import { photoThumb, photoToView } from "../lib/photo.ts";
 import type { State } from "../state.ts";
 import { galleryLink } from "../utils.ts";
 
···
     return new Response("Error fetching blob", { status: 500 });
   }
 };
+
+export const uploadPhoto: RouteHandler = async (
+  req,
+  _params,
+  ctx: BffContext<State>,
+) => {
+  const { did } = ctx.requireAuth();
+  ctx.rateLimit({
+    namespace: "upload",
+    points: 1,
+    limit: 50,
+    window: 24 * 60 * 60 * 1000, // 24 hours
+  });
+  if (!ctx.agent) {
+    return new Response("Agent has not been initialized", { status: 401 });
+  }
+  try {
+    const formData = await req.formData();
+    const file = formData.get("file") as File;
+    const width = Number(formData.get("width")) || undefined;
+    const height = Number(formData.get("height")) || undefined;
+    if (!file) {
+      return new Response("No file", { status: 400 });
+    }
+    // Check if file size exceeds 20MB limit
+    const maxSizeBytes = 20 * 1000 * 1000; // 20MB in bytes
+    if (file.size > maxSizeBytes) {
+      return new Response("File too large. Maximum size is 20MB", {
+        status: 400,
+      });
+    }
+    const blobResponse = await ctx.agent.uploadBlob(file);
+    const photoUri = await ctx.createRecord<Photo>("social.grain.photo", {
+      photo: blobResponse.data.blob,
+      aspectRatio: width && height
+        ? {
+          width,
+          height,
+        }
+        : undefined,
+      alt: "",
+      createdAt: new Date().toISOString(),
+    });
+    return ctx.html(
+      <PhotoPreview
+        src={photoThumb(did, blobResponse.data.blob.ref.toString())}
+        uri={photoUri}
+      />,
+    );
+  } catch (e) {
+    console.error("Error in uploadStart:", e);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+};

src/routes/record.tsx

···
+import { Record as Profile } from "$lexicon/types/social/grain/actor/profile.ts";
+import { Record as Favorite } from "$lexicon/types/social/grain/favorite.ts";
+import { Record as Gallery } from "$lexicon/types/social/grain/gallery.ts";
+import { Record as GalleryItem } from "$lexicon/types/social/grain/gallery/item.ts";
+import { Record as Photo } from "$lexicon/types/social/grain/photo.ts";
+import { AtUri } from "@atproto/syntax";
+import { BffContext, RouteHandler, WithBffMeta } from "@bigmoves/bff";
+import { BadRequestError, NotFoundError, ServerError } from "../lib/errors.ts";
+import type { State } from "../state.ts";
+import { galleryLink } from "../utils.ts";
+
+export const handler: RouteHandler = (
+  _req,
+  params,
+  ctx: BffContext<State>,
+) => {
+  const { did, collection, rkey } = params;
+
+  if (!did || !collection || !rkey) {
+    throw new BadRequestError("Invalid parameters for record handler");
+  }
+
+  if (!did.startsWith("did:")) {
+    throw new NotFoundError();
+  }
+
+  const actor = ctx.indexService.getActor(did);
+  if (!actor) {
+    throw new NotFoundError(
+      `Actor not found or missing handle for did: ${did}`,
+    );
+  }
+
+  switch (collection) {
+    case "social.grain.actor.profile": {
+      if (rkey !== "self") {
+        throw new NotFoundError(`Invalid rkey for actor profile: ${rkey}`);
+      }
+      const profile = ctx.indexService.getRecord<WithBffMeta<Profile>>(
+        `at://${did}/social.grain.actor.profile/${rkey}`,
+      );
+      if (!profile) {
+        throw new NotFoundError(
+          `Profile not found for did: ${did}, rkey: ${rkey}`,
+        );
+      }
+      return ctx.redirect(`/profile/${actor.handle}`);
+    }
+
+    case "social.grain.gallery": {
+      const gallery = ctx.indexService.getRecord<WithBffMeta<Gallery>>(
+        `at://${did}/social.grain.gallery/${rkey}`,
+      );
+      if (!gallery) {
+        throw new NotFoundError(
+          `Gallery not found for did: ${did}, rkey: ${rkey}`,
+        );
+      }
+      return ctx.redirect(galleryLink(
+        actor.handle,
+        new AtUri(gallery.uri).rkey,
+      ));
+    }
+
+    case "social.grain.gallery.item": {
+      const galleryItem = ctx.indexService.getRecord<WithBffMeta<GalleryItem>>(
+        `at://${did}/social.grain.gallery.item/${rkey}`,
+      );
+      if (!galleryItem) {
+        throw new NotFoundError(
+          `Gallery item not found for did: ${did}, rkey: ${rkey}`,
+        );
+      }
+      const photo = ctx.indexService.getRecord<WithBffMeta<Photo>>(
+        galleryItem.item,
+      );
+      if (!photo) {
+        throw new NotFoundError(
+          `Photo not found for gallery item: ${galleryItem.item}`,
+        );
+      }
+      return ctx.redirect(
+        `/actions/get-blob?did=${did}&cid=${photo.photo.ref.toString()}`,
+      );
+    }
+
+    case "social.grain.photo": {
+      const photo = ctx.indexService.getRecord<WithBffMeta<Photo>>(
+        `at://${did}/social.grain.photo/${rkey}`,
+      );
+      if (!photo) {
+        throw new NotFoundError(
+          `Photo not found for did: ${did}, rkey: ${rkey}`,
+        );
+      }
+      return ctx.redirect(
+        `/actions/get-blob?did=${did}&cid=${photo.photo.ref.toString()}`,
+      );
+    }
+
+    case "social.grain.favorite": {
+      const favorite = ctx.indexService.getRecord<WithBffMeta<Favorite>>(
+        `at://${did}/social.grain.favorite/${rkey}`,
+      );
+      if (!favorite) {
+        throw new NotFoundError(
+          `Favorite not found for did: ${did}, rkey: ${rkey}`,
+        );
+      }
+      const subjectActor = ctx.indexService.getActor(
+        new AtUri(favorite.subject).hostname,
+      );
+      if (!subjectActor) {
+        throw new NotFoundError(
+          `Subject actor not found or missing handle for subject: ${favorite.subject}`,
+        );
+      }
+      return ctx.redirect(
+        galleryLink(subjectActor.handle, new AtUri(favorite.subject).rkey),
+      );
+    }
+
+    default:
+      throw new ServerError(`Unsupported collection: ${collection}`);
+  }
+};