feat: enhance notification system with detailed views and reason subjects; update related schemas and functions

__generated__/lexicons.ts

···
             type: 'ref',
             ref: 'lex:social.grain.actor.defs#profileView',
           },
+          reasonSubject: {
+            type: 'string',
+            format: 'at-uri',
+          },
           reason: {
             type: 'string',
             description:
···
               'unknown',
             ],
           },
-          reasonSubject: {
+          record: {
+            type: 'unknown',
+          },
+          isRead: {
+            type: 'boolean',
+          },
+          indexedAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+        },
+      },
+      notificationViewDetailed: {
+        type: 'object',
+        required: [
+          'uri',
+          'cid',
+          'author',
+          'reason',
+          'record',
+          'isRead',
+          'indexedAt',
+        ],
+        properties: {
+          uri: {
             type: 'string',
             format: 'at-uri',
           },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          author: {
+            type: 'ref',
+            ref: 'lex:social.grain.actor.defs#profileView',
+          },
+          reason: {
+            type: 'string',
+            description:
+              'The reason why this notification was delivered - e.g. your gallery was favd, or you received a new follower.',
+            knownValues: [
+              'follow',
+              'gallery-favorite',
+              'gallery-comment',
+              'reply',
+              'gallery-mention',
+              'gallery-comment-mention',
+              'unknown',
+            ],
+          },
+          reasonSubject: {
+            type: 'union',
+            refs: [
+              'lex:social.grain.actor.defs#profileView',
+              'lex:social.grain.comment.defs#commentView',
+              'lex:social.grain.gallery.defs#galleryView',
+            ],
+          },
           record: {
             type: 'unknown',
           },
···
                 type: 'array',
                 items: {
                   type: 'ref',
-                  ref: 'lex:social.grain.notification.defs#notificationView',
+                  ref: 'lex:social.grain.notification.defs#notificationViewDetailed',
                 },
               },
               seenAt: {

__generated__/types/social/grain/notification/defs.ts

···
   type OmitKey,
 } from '../../../../util.ts'
 import type * as SocialGrainActorDefs from '../actor/defs.ts'
+import type * as SocialGrainCommentDefs from '../comment/defs.ts'
+import type * as SocialGrainGalleryDefs from '../gallery/defs.ts'
 
 const is$typed = _is$typed,
   validate = _validate
···
   uri: string
   cid: string
   author: SocialGrainActorDefs.ProfileView
+  reasonSubject?: string
   /** The reason why this notification was delivered - e.g. your gallery was favd, or you received a new follower. */
   reason:
     | 'follow'
···
     | 'gallery-comment-mention'
     | 'unknown'
     | (string & {})
-  reasonSubject?: string
   record: { [_ in string]: unknown }
   isRead: boolean
   indexedAt: string
···
 export function validateNotificationView<V>(v: V) {
   return validate<NotificationView & V>(v, id, hashNotificationView)
 }
+
+export interface NotificationViewDetailed {
+  $type?: 'social.grain.notification.defs#notificationViewDetailed'
+  uri: string
+  cid: string
+  author: SocialGrainActorDefs.ProfileView
+  /** The reason why this notification was delivered - e.g. your gallery was favd, or you received a new follower. */
+  reason:
+    | 'follow'
+    | 'gallery-favorite'
+    | 'gallery-comment'
+    | 'reply'
+    | 'gallery-mention'
+    | 'gallery-comment-mention'
+    | 'unknown'
+    | (string & {})
+  reasonSubject?:
+    | $Typed<SocialGrainActorDefs.ProfileView>
+    | $Typed<SocialGrainCommentDefs.CommentView>
+    | $Typed<SocialGrainGalleryDefs.GalleryView>
+    | { $type: string }
+  record: { [_ in string]: unknown }
+  isRead: boolean
+  indexedAt: string
+}
+
+const hashNotificationViewDetailed = 'notificationViewDetailed'
+
+export function isNotificationViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashNotificationViewDetailed)
+}
+
+export function validateNotificationViewDetailed<V>(v: V) {
+  return validate<NotificationViewDetailed & V>(
+    v,
+    id,
+    hashNotificationViewDetailed,
+  )
+}

__generated__/types/social/grain/notification/getNotifications.ts

···
 
 export interface OutputSchema {
   cursor?: string;
-  notifications: SocialGrainNotificationDefs.NotificationView[];
+  notifications: SocialGrainNotificationDefs.NotificationViewDetailed[];
   seenAt?: string;
 }
 

lexicons/social/grain/notification/defs.json

···
           "type": "ref",
           "ref": "social.grain.actor.defs#profileView"
         },
+        "reasonSubject": { "type": "string", "format": "at-uri" },
         "reason": {
           "type": "string",
           "description": "The reason why this notification was delivered - e.g. your gallery was favd, or you received a new follower.",
···
             "unknown"
           ]
         },
-        "reasonSubject": { "type": "string", "format": "at-uri" },
+        "record": { "type": "unknown" },
+        "isRead": { "type": "boolean" },
+        "indexedAt": { "type": "string", "format": "datetime" }
+      }
+    },
+    "notificationViewDetailed": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "author",
+        "reason",
+        "record",
+        "isRead",
+        "indexedAt"
+      ],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" },
+        "author": {
+          "type": "ref",
+          "ref": "social.grain.actor.defs#profileView"
+        },
+        "reason": {
+          "type": "string",
+          "description": "The reason why this notification was delivered - e.g. your gallery was favd, or you received a new follower.",
+          "knownValues": [
+            "follow",
+            "gallery-favorite",
+            "gallery-comment",
+            "reply",
+            "gallery-mention",
+            "gallery-comment-mention",
+            "unknown"
+          ]
+        },
+        "reasonSubject": {
+          "type": "union",
+          "refs": [
+            "social.grain.actor.defs#profileView",
+            "social.grain.comment.defs#commentView",
+            "social.grain.gallery.defs#galleryView"
+          ]
+        },
         "record": { "type": "unknown" },
         "isRead": { "type": "boolean" },
         "indexedAt": { "type": "string", "format": "datetime" }

lexicons/social/grain/notification/getNotifications.json

···
               "type": "array",
               "items": {
                 "type": "ref",
-                "ref": "social.grain.notification.defs#notificationView"
+                "ref": "social.grain.notification.defs#notificationViewDetailed"
               }
             },
             "seenAt": { "type": "string", "format": "datetime" }

src/api/mod.ts

···
   getFollowingWithProfiles,
 } from "../lib/follow.ts";
 import { getGalleriesByHashtag, getGallery } from "../lib/gallery.ts";
-import { getNotifications } from "../lib/notifications.ts";
+import { getNotificationsDetailed } from "../lib/notifications.ts";
 import { getTimeline } from "../lib/timeline.ts";
 import { getGalleryComments } from "../modules/comments.tsx";
 
···
     (_req, _params, ctx) => {
       // @TODO: this redirects, we should have a json response
       ctx.requireAuth();
-      const notifications = getNotifications(
+      const notifications = getNotificationsDetailed(
         ctx,
       );
       return ctx.json(

src/lib/actor.ts

···
 import { Record as Photo } from "$lexicon/types/social/grain/photo.ts";
 import { isPhotoView } from "$lexicon/types/social/grain/photo/defs.ts";
 import { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
-import { Un$Typed } from "$lexicon/util.ts";
+import { $Typed } from "$lexicon/util.ts";
 import { BffContext, WithBffMeta } from "@bigmoves/bff";
 import { getFollow, getFollowersCount, getFollowsCount } from "./follow.ts";
 import {
···
 export function profileToView(
   record: WithBffMeta<GrainProfile>,
   handle: string,
-): Un$Typed<ProfileView> {
+): $Typed<ProfileView> {
   return {
+    $type: "social.grain.actor.defs#profileView",
     cid: record.cid,
     did: record.did,
     handle,
···
   galleryCount: number;
   viewer: ViewerState;
   cameras?: string[];
-}): Un$Typed<ProfileViewDetailed> {
+}): $Typed<ProfileViewDetailed> {
   const {
     record,
     handle,
···
     cameras,
   } = params;
   return {
+    $type: "social.grain.actor.defs#profileViewDetailed",
     cid: record.cid,
     did: record.did,
     handle,

src/lib/notifications.ts

···
   isRecord as isComment,
   Record as Comment,
 } from "$lexicon/types/social/grain/comment.ts";
+import { CommentView } from "$lexicon/types/social/grain/comment/defs.ts";
 import {
   isRecord as isFavorite,
   Record as Favorite,
···
   isRecord as isGallery,
   Record as Gallery,
 } from "$lexicon/types/social/grain/gallery.ts";
+import { GalleryView } from "$lexicon/types/social/grain/gallery/defs.ts";
 import {
   isRecord as isFollow,
   Record as Follow,
 } from "$lexicon/types/social/grain/graph/follow.ts";
-import { NotificationView } from "$lexicon/types/social/grain/notification/defs.ts";
-import { Un$Typed } from "$lexicon/util.ts";
+import {
+  NotificationView,
+  NotificationViewDetailed,
+} from "$lexicon/types/social/grain/notification/defs.ts";
+import { $Typed, Un$Typed } from "$lexicon/util.ts";
+import { AtUri } from "@atproto/syntax";
 import { ActorTable, BffContext, WithBffMeta } from "@bigmoves/bff";
+import { getComment } from "../modules/comments.tsx";
 import { getActorProfile } from "./actor.ts";
+import { getGallery } from "./gallery.ts";
 
 export type NotificationRecords = WithBffMeta<
   Favorite | Follow | Comment | Gallery
···
   }
   return false;
 }
+
+export function getNotificationsDetailed(
+  ctx: BffContext,
+): Un$Typed<NotificationViewDetailed>[] {
+  const notifications = ctx.getNotifications<NotificationRecords>();
+  return notifications
+    .filter(
+      (notification) =>
+        notification.$type === "social.grain.favorite" ||
+        notification.$type === "social.grain.graph.follow" ||
+        notification.$type === "social.grain.comment" ||
+        notification.$type === "social.grain.gallery",
+    )
+    .map((notification) => {
+      const actor = ctx.indexService.getActor(notification.did);
+      const authorProfile = getActorProfile(notification.did, ctx);
+      if (!actor || !authorProfile) return null;
+
+      let reasonSubject:
+        | $Typed<GalleryView | CommentView | ProfileView>
+        | undefined = undefined;
+      if (notification.$type === "social.grain.favorite") {
+        // Favorite: reasonSubject is the gallery view
+        const galleryUri = notification.subject;
+        try {
+          const atUri = new AtUri(galleryUri);
+          const did = atUri.hostname;
+          const rkey = atUri.rkey;
+          reasonSubject = getGallery(did, rkey, ctx) ?? undefined;
+        } catch {
+          reasonSubject = undefined;
+        }
+      } else if (notification.$type === "social.grain.graph.follow") {
+        reasonSubject = getActorProfile(
+          notification.subject,
+          ctx,
+        ) ?? undefined;
+      } else if (notification.$type === "social.grain.comment") {
+        // Hydrate comment with author, subject, and focus
+        reasonSubject = getComment(notification.uri, ctx) ?? undefined;
+      } else if (notification.$type === "social.grain.gallery") {
+        try {
+          const atUri = new AtUri(notification.uri);
+          const did = atUri.hostname;
+          const rkey = atUri.rkey;
+          reasonSubject = getGallery(did, rkey, ctx) ?? undefined;
+        } catch {
+          reasonSubject = undefined;
+        }
+      }
+
+      return notificationDetailedToView(
+        notification,
+        authorProfile,
+        ctx.currentUser,
+        reasonSubject,
+      );
+    })
+    .filter((view): view is Un$Typed<NotificationViewDetailed> =>
+      Boolean(view)
+    );
+}
+
+export function notificationDetailedToView(
+  record: NotificationRecords,
+  author: $Typed<ProfileView>,
+  currentUser?: ActorTable,
+  reasonSubject?: $Typed<GalleryView | CommentView | ProfileView>,
+): Un$Typed<NotificationViewDetailed> {
+  let reason: string;
+  if (isFavorite(record)) {
+    reason = "gallery-favorite";
+  } else if (isFollow(record)) {
+    reason = "follow";
+  } else if (
+    isComment(record) &&
+    record.replyTo
+  ) {
+    if (
+      recordHasMentionFacet(
+        record,
+        currentUser?.did,
+      )
+    ) {
+      reason = "gallery-comment-mention";
+    } else {
+      reason = "reply";
+    }
+  } else if (isComment(record)) {
+    if (
+      recordHasMentionFacet(
+        record,
+        currentUser?.did,
+      )
+    ) {
+      reason = "gallery-comment-mention";
+    } else {
+      reason = "gallery-comment";
+    }
+  } else if (
+    isGallery(record) && recordHasMentionFacet(
+      record,
+      currentUser?.did,
+    )
+  ) {
+    reason = "gallery-mention";
+  } else {
+    reason = "unknown";
+  }
+  const isRead = currentUser?.lastSeenNotifs
+    ? record.createdAt <= currentUser.lastSeenNotifs
+    : false;
+  return {
+    uri: record.uri,
+    cid: record.cid,
+    author,
+    reason,
+    reasonSubject,
+    record,
+    isRead,
+    indexedAt: record.indexedAt,
+  };
+}

src/modules/comments.tsx

···
   isPhotoView,
   PhotoView,
 } from "$lexicon/types/social/grain/photo/defs.ts";
+import { $Typed } from "$lexicon/util.ts";
 import { Facet } from "@atproto/api";
 import { AtUri } from "@atproto/syntax";
 import { BffContext, BffMiddleware, route, WithBffMeta } from "@bigmoves/bff";
···
   );
 }
 
-function getComment(uri: string, ctx: BffContext) {
+export function getComment(
+  uri: string,
+  ctx: BffContext,
+) {
   const { items: comments } = ctx.indexService.getRecords<WithBffMeta<Comment>>(
     "social.grain.comment",
     {
···
   return commentToView(comment, author, subject, focus);
 }
 
-function commentToView(
+export function commentToView(
   record: WithBffMeta<Comment>,
   author: ProfileView,
   subject?: GalleryView,
   focus?: PhotoView,
-): CommentView {
+): $Typed<CommentView> {
   return {
+    $type: "social.grain.comment.defs#commentView",
     uri: record.uri,
     cid: record.cid,
     text: record.text,