view server notifs

index/spacedust.ts

···
       srccol,
       suburi,
       subdid,
-      subcol
+      subcol,
+      indexedAt
     ) VALUES (
       '${aturi}',
       '${srcdid}',
···
       '${msg.link.source}',
       '${subject}',
       '${subdid}',
-      '${subscol}'
+      '${subscol}',
+      '${Date.now()}'
     );
   `);
   //if (!value) return;

indexserver.ts

···
             srccol,
             suburi,
             subdid,
-            subcol
-          ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+            subcol,
+            indexedAt
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
           [
             srcUri, // full AT URI of the source record
             srcDid, // did: of the source
···
             subUri, // full AT URI of the subject (linked record)
             subDid, // did: of the subject
             subCol, // subject collection (can be inferred or passed)
+            Date.now()
           ]
         );
       }
···
   );
 }
 
-function uncid(anything: any): string | null {
+export function uncid(anything: any): string | null {
   return (
     ((anything as Record<string, unknown>)?.["$link"] as string | null) || null
   );

main-view.ts

···
       });
     }
     console.log(`request for "${pathname}"`);
-
-    let authdid: string | undefined = undefined;
-    try {
-      authdid = (await getAuthenticatedDid(req)) ?? undefined;
-    } catch (_e) {
-      // nothing lol
-    }
-    const auth = authdid
-      ? genericViewServer.handlesDid(authdid)
-        ? authdid
-        : undefined
-      : undefined;
-    console.log("authed:", auth);
     return await genericViewServer.viewServerHandler(req);
   }
 );

utils/dbuser.ts

···
       avatarcid TEXT,
       avatarmime TEXT,
       bannercid TEXT,
-      bannermime TEXT
-      -- TODO please add pinned posts
+      bannermime TEXT,
+      pinned TEXT
     );
     ${createIndexINE} idx_actor_profile_did ON app_bsky_actor_profile(did);
   
···
       srccol TEXT,
       suburi TEXT,
       subdid TEXT,
-      subcol TEXT
-      -- TODO please add indexedAt
+      subcol TEXT,
+      indexedAt INTEGER NOT NULL
     );
     ${createIndexINE} idx_backlink_subdid_mod ON backlink_skeleton(subdid, srcdid);
     ${createIndexINE} idx_backlink_suburi_mod ON backlink_skeleton(suburi, srcdid);

viewserver.ts

···
   getSlingshotRecord,
   withCors,
 } from "./utils/server.ts";
+import QuickLRU from "npm:quick-lru";
 import { validateRecord } from "./utils/records.ts";
 import { indexHandlerContext } from "./index/types.ts";
 import { Database } from "jsr:@db/sqlite@0.11";
 import { JetstreamManager, SpacedustManager } from "./utils/sharders.ts";
 import { SpacedustLinkMessage } from "./index/spacedust.ts";
 import { setupUserDb } from "./utils/dbuser.ts";
+import { config } from "./config.ts";
+import { AtUri } from "npm:@atproto/api";
+import { CID } from "../../Library/Caches/deno/npm/registry.npmjs.org/multiformats/9.9.0/cjs/src/cid.js";
+import { uncid } from "./indexserver.ts";
+import { getAuthenticatedDid } from "./utils/auth.ts";
 
 export interface ViewServerConfig {
   baseDbPath: string;
···
     const searchParams = searchParamsToJson(url.searchParams);
     const jsonUntyped = searchParams;
 
+    let tempauthdid: string | undefined = undefined;
+    try {
+      tempauthdid = (await getAuthenticatedDid(req)) ?? undefined;
+    } catch (_e) {
+      // nothing lol
+    }
+    const authdid = tempauthdid
+      ? this.handlesDid(tempauthdid)
+        ? tempauthdid
+        : undefined
+      : undefined;
+    console.log("authed:", authdid);
+
     if (xrpcMethod === "app.bsky.unspecced.getTrendingTopics") {
       // const jsonTyped =
       //   jsonUntyped as ViewServerTypes.AppBskyUnspeccedGetTrendingTopics.QueryParams;
···
         },
         {
           $type: "app.bsky.unspecced.defs#trendingTopic",
-          topic: "Red Dwarf Lite",
-          displayName: "Red Dwarf Lite",
-          description: "Red Dwarf Lite",
-          link: "https://reddwarflite.whey.party/",
+          topic: "this View Server url",
+          displayName: "this View Server url",
+          description: "this View Server url",
+          link: config.viewServer.host,
+        },
+        {
+          $type: "app.bsky.unspecced.defs#trendingTopic",
+          topic: "this social-app fork url",
+          displayName: "this social-app fork url",
+          description: "this social-app fork url",
+          link: "https://github.com/rimar1337/social-app/tree/publicappview-colorable",
         },
         {
           $type: "app.bsky.unspecced.defs#trendingTopic",
···
         JSON.stringify({
           error: "XRPCNotSupported",
           message:
-            "HEY hello there my name is whey dot party and you have used my custom appview that is very cool but have you considered that XRPC Not Supported",
+            "(no auth) HEY hello there my name is whey dot party and you have used my custom appview that is very cool but have you considered that XRPC Not Supported",
         }),
         {
           status: 404,
···
         JSON.stringify({
           error: "XRPCNotSupported",
           message:
-            "HEY hello there my name is whey dot party and you have used my custom appview that is very cool but have you considered that XRPC Not Supported",
+            "(getservices / getconfig) HEY hello there my name is whey dot party and you have used my custom appview that is very cool but have you considered that XRPC Not Supported",
         }),
         {
           status: 404,
···
           }
 
           const postResp = await ky
+            // TODO aaaaaa dont do this please use the new getServiceEndpointFromIdentity()
             .get(`https://api.bsky.app/xrpc/app.bsky.feed.getPosts`, {
               // headers: {
               //   Authorization: proxyauth,
···
         const jsonTyped =
           jsonUntyped as ViewServerTypes.AppBskyActorGetProfile.QueryParams;
 
-        const userindexservice = "";
-        const isbskyfallback = true;
-        if (isbskyfallback) {
-          return this.sendItToApiBskyApp(req);
-        }
-
         const response: ViewServerTypes.AppBskyActorGetProfile.OutputSchema =
-          {};
+          ((await this.resolveGetProfiles([jsonTyped.actor])) ?? [])[0];
 
         return new Response(JSON.stringify(response), {
           headers: withCors({ "Content-Type": "application/json" }),
···
         const jsonTyped =
           jsonUntyped as ViewServerTypes.AppBskyActorGetProfiles.QueryParams;
 
-        const userindexservice = "";
-        const isbskyfallback = true;
-        if (isbskyfallback) {
-          return this.sendItToApiBskyApp(req);
-        }
-
-        const response: ViewServerTypes.AppBskyActorGetProfiles.OutputSchema =
-          {};
+        const response: ViewServerTypes.AppBskyActorGetProfiles.OutputSchema = {
+          profiles: (await this.resolveGetProfiles(jsonTyped.actors)) ?? [],
+        };
 
         return new Response(JSON.stringify(response), {
           headers: withCors({ "Content-Type": "application/json" }),
···
       //     headers: withCors({ "Content-Type": "application/json" }),
       //   });
       // }
-      // case "app.bsky.notification.listNotifications": {
-      //   const jsonTyped =
-      //     jsonUntyped as ViewServerTypes.AppBskyNotificationListNotifications.QueryParams;
+      case "app.bsky.notification.listNotifications": {
+        if (!authdid) return new Response("Not Found", { status: 404 });
+        const jsonTyped =
+          jsonUntyped as ViewServerTypes.AppBskyNotificationListNotifications.QueryParams;
+
+        const response: ViewServerTypes.AppBskyNotificationListNotifications.OutputSchema =
+          await this.queryNotificationsList(authdid, jsonTyped.cursor);
 
-      //   const response: ViewServerTypes.AppBskyNotificationListNotifications.OutputSchema = {};
+        return new Response(JSON.stringify(response), {
+          headers: withCors({ "Content-Type": "application/json" }),
+        });
+      }
+      case "app.bsky.feed.getPosts": {
+        const jsonTyped =
+          jsonUntyped as ViewServerTypes.AppBskyFeedGetPosts.QueryParams;
+        const inputUris = Array.isArray(jsonTyped.uris)
+          ? jsonTyped.uris
+          : [jsonTyped.uris];
+        const response: ViewServerTypes.AppBskyFeedGetPosts.OutputSchema = {
+          posts: await this.resolveGetPosts(inputUris),
+        };
 
-      //   return new Response(JSON.stringify(response), {
-      //     headers: withCors({ "Content-Type": "application/json" }),
-      //   });
-      // }
+        return new Response(JSON.stringify(response), {
+          headers: withCors({ "Content-Type": "application/json" }),
+        });
+      }
 
       case "app.bsky.unspecced.getConfig": {
         const jsonTyped =
···
           JSON.stringify({
             error: "XRPCNotSupported",
             message:
-              "HEY hello there my name is whey dot party and you have used my custom appview that is very cool but have you considered that XRPC Not Supported",
+              "(default) HEY hello there my name is whey dot party and you have used my custom appview that is very cool but have you considered that XRPC Not Supported",
           }),
           {
             status: 404,
···
   public handlesDid(did: string): boolean {
     return this.userManager.handlesDid(did);
   }
+
+  async resolveGetPosts(
+    uris: string[]
+  ): Promise<ATPAPI.AppBskyFeedDefs.PostView[]> {
+    const grouped: Record<string, string[]> = {};
+
+    // Group URIs by resolved endpoint
+    for (const uri of uris) {
+      const did = new AtUri(uri).host;
+      const endpoint = await getSkyliteEndpoint(did);
+      if (!endpoint) continue;
+
+      if (!grouped[endpoint]) {
+        grouped[endpoint] = [];
+      }
+      grouped[endpoint].push(uri);
+    }
+
+    const postviews: ATPAPI.AppBskyFeedDefs.PostView[] = [];
+
+    // Fetch posts per endpoint
+    for (const [endpoint, urisForEndpoint] of Object.entries(grouped)) {
+      const query = urisForEndpoint
+        .map((u) => `uris=${encodeURIComponent(u)}`)
+        .join("&");
+
+      const url = `${endpoint}/xrpc/app.bsky.feed.getPosts?${query}`;
+      const resp = await fetch(url);
+      if (!resp.ok) {
+        throw new Error(
+          `Failed to fetch posts from ${endpoint} for uris=${urisForEndpoint.join(
+            ","
+          )}`
+        );
+      }
+
+      const raw =
+        (await resp.json()) as ATPAPI.AppBskyFeedGetPosts.OutputSchema;
+      postviews.push(...raw.posts);
+    }
+
+    return postviews;
+  }
+
+  async resolveGetProfiles(
+    dids: string[]
+  ): Promise<ATPAPI.AppBskyActorDefs.ProfileViewDetailed[] | undefined> {
+    const profiles: ATPAPI.AppBskyActorDefs.ProfileViewDetailed[] = [];
+
+    for (const did of dids) {
+      const endpoint = await getSkyliteEndpoint(did);
+      const url = `${endpoint}/xrpc/app.bsky.actor.getProfile?actor=${encodeURIComponent(
+        did
+      )}`;
+      const resp = await fetch(url);
+      if (!resp.ok)
+        throw new Error(`Failed to fetch profile for ${did} via ${url}`);
+
+      const raw =
+        (await resp.json()) as ATPAPI.AppBskyActorGetProfile.OutputSchema;
+      profiles.push(raw);
+    }
+
+    return profiles;
+  }
+  async queryNotificationsList(
+    did: string,
+    cursor?: string
+  ): Promise<ATPAPI.AppBskyNotificationListNotifications.OutputSchema> {
+    if (!this.handlesDid(did)) {
+      return { notifications: [] };
+    }
+    const db = this.userManager.getDbForDid(did);
+    if (!db) {
+      return { notifications: [] };
+    }
+
+    const NOTIFS_LIMIT = 30;
+    const mapReason = (
+      field: string
+    ):
+      | ATPAPI.AppBskyNotificationListNotifications.Notification["reason"]
+      | undefined => {
+      switch (field) {
+        //'like' | 'repost' | 'follow' | 'mention' | 'reply' | 'quote' | 'starterpack-joined' | 'verified' | 'unverified' | 'like-via-repost' | 'repost-via-repost' |
+        case "app.bsky.feed.like:subject.uri":
+          return "like";
+        case "app.bsky.feed.like:via.uri":
+          return "liked-via-repost";
+        case "app.bsky.feed.repost:subject.uri":
+          return "repost";
+        case "app.bsky.feed.repost:via.uri":
+          return "repost-via-repost";
+        case "app.bsky.feed.post:reply.root.uri":
+          return "reply";
+        case "app.bsky.feed.post:reply.parent.uri":
+          return "reply";
+        case "app.bsky.feed.post:embed.media.record.record.uri":
+          return "quote";
+        case "app.bsky.feed.post:embed.record.uri":
+          return "quote";
+        //case"app.bsky.feed.threadgate:post": return "threadgate subject
+        //case"app.bsky.feed.threadgate:hiddenReplies": return "threadgate items (array)
+        case "app.bsky.feed.post:facets.features.did":
+          return "mention";
+        //case"app.bsky.graph.block:subject": return "blocks
+        case "app.bsky.graph.follow:subject":
+          return "follow";
+        //case"app.bsky.graph.listblock:subject": return "list item (blocks)
+        //case"app.bsky.graph.listblock:list": return "blocklist mention (might not exist)
+        //case"app.bsky.graph.listitem:subject": return "list item (blocks)
+        //"app.bsky.graph.listitem:list": return "list mention
+        // case "like": return "like";
+        // case "repost": return "repost";
+        // case "follow": return "follow";
+        // case "replyparent": return "reply";
+        // case "replyroot": return "reply";
+        // case "mention": return "mention";
+        default:
+          return undefined;
+      }
+    };
+
+    // --- Build Query ---
+    let query = `
+      SELECT srcuri, suburi, srcfield, indexedat
+      FROM backlink_skeleton
+      WHERE
+        -- Find actions targeting the user's content or profile
+        (suburi LIKE ? OR suburi = ?)
+        -- Exclude notifications from the user themselves
+        AND srcuri NOT LIKE ?
+    `;
+    const params: (string | number)[] = [`at://${did}/%`, did, `at://${did}/%`];
+
+    if (cursor) {
+      const [indexedat, srcuri] = cursor.split("::");
+      if (indexedat && srcuri) {
+        query += ` AND (indexedat < ? OR (indexedat = ? AND srcuri < ?))`;
+        params.push(parseInt(indexedat, 10), parseInt(indexedat, 10), srcuri);
+      }
+    }
+
+    query += ` ORDER BY indexedat DESC, srcuri DESC LIMIT ${NOTIFS_LIMIT}`;
+
+    // --- Fetch and Process ---
+    const stmt = db.prepare(query);
+    const rows = stmt.all(...params) as {
+      srcuri: string;
+      suburi: string;
+      srcfield: string;
+      indexedat: number;
+    }[];
+
+    const notificationPromises = rows.map(async (row) => {
+      const reason = mapReason(row.srcfield);
+      // Skip if it's a backlink type we don't have a notification for
+      if (!reason) return null;
+
+      const srcURI = new AtUri(row.srcuri);
+      const [author, getrecord] = await Promise.all([
+        await this.resolveProfileView(srcURI.host, ""),
+        await getSlingshotRecord(srcURI.host, srcURI.collection, srcURI.rkey),
+        // TODO: shit histhi shitshit
+        //this.queryProfile(authorDid),
+        // Assumes you have a method to fetch the raw record content by URI and CID
+        // This would fetch the like, repost, follow, or post record itself.
+        //this.getRecord(row.srcuri, row.srccid),
+      ]);
+      const reasonsubject = row.suburi;
+      // If we can't resolve the author or the record, we can't form a valid notification
+      if (!author || !getrecord || !reason || !reasonsubject) return null;
+
+      return {
+        uri: row.srcuri,
+        cid: getrecord.cid,
+        author: author,
+        reason: reason,
+        // The reasonSubject is the URI of the post that was liked, reposted, or replied to
+        reasonSubject: reasonsubject,
+        record: getrecord.value,
+        isRead: false, // Placeholder for read-state logic
+        indexedAt: new Date(/*row.indexedat*/).toISOString(),
+        // labels: [], // Placeholder for label logic
+      } as ATPAPI.AppBskyNotificationListNotifications.Notification;
+    });
+
+    const notifications = (await Promise.all(notificationPromises)).filter(
+      (n): n is ATPAPI.AppBskyNotificationListNotifications.Notification => !!n
+    );
+
+    // --- Create next cursor ---
+    const lastItem = rows[rows.length - 1];
+    const nextCursor = lastItem
+      ? `${lastItem.indexedat}::${lastItem.srcuri}`
+      : undefined;
+
+    return {
+      cursor: nextCursor,
+      notifications: notifications,
+    };
+  }
+  async resolveProfileView(
+    did: string,
+    type: ""
+  ): Promise<ATPAPI.AppBskyActorDefs.ProfileView | undefined>;
+  async resolveProfileView(
+    did: string,
+    type: "Basic"
+  ): Promise<ATPAPI.AppBskyActorDefs.ProfileViewBasic | undefined>;
+  async resolveProfileView(
+    did: string,
+    type: "Detailed"
+  ): Promise<ATPAPI.AppBskyActorDefs.ProfileViewDetailed | undefined>;
+  async resolveProfileView(
+    did: string,
+    type: "" | "Basic" | "Detailed"
+  ): Promise<
+    | ATPAPI.AppBskyActorDefs.ProfileView
+    | ATPAPI.AppBskyActorDefs.ProfileViewBasic
+    | ATPAPI.AppBskyActorDefs.ProfileViewDetailed
+    | undefined
+  > {
+    const record = (
+      await getSlingshotRecord(did, "app.bsky.actor.profile", "self")
+    ).value as ATPAPI.AppBskyActorProfile.Record;
+
+    const identity = await resolveIdentity(did);
+    const avatarcid = uncid(record.avatar?.ref);
+    const avatar = avatarcid
+      ? buildBlobUrl(identity.pds, identity.did, avatarcid)
+      : undefined;
+    const bannercid = uncid(record.banner?.ref);
+    const banner = bannercid
+      ? buildBlobUrl(identity.pds, identity.did, bannercid)
+      : undefined;
+    // simulate different types returned
+    switch (type) {
+      case "": {
+        const result: ATPAPI.AppBskyActorDefs.ProfileView = {
+          $type: "app.bsky.actor.defs#profileView",
+          did: did,
+          handle: identity.handle,
+          displayName: record.displayName ?? identity.handle,
+          description: record.description ?? undefined,
+          avatar: avatar, // create profile URL from resolved identity
+          //associated?: ProfileAssociated,
+          indexedAt: record.createdAt
+            ? new Date(record.createdAt).toISOString()
+            : undefined,
+          createdAt: record.createdAt
+            ? new Date(record.createdAt).toISOString()
+            : undefined,
+          //viewer?: ViewerState,
+          //labels?: ComAtprotoLabelDefs.Label[],
+          //verification?: VerificationState,
+          //status?: StatusView,
+        };
+        return result;
+      }
+      case "Basic": {
+        const result: ATPAPI.AppBskyActorDefs.ProfileViewBasic = {
+          $type: "app.bsky.actor.defs#profileViewBasic",
+          did: did,
+          handle: identity.handle,
+          displayName: record.displayName ?? identity.handle,
+          avatar: avatar, // create profile URL from resolved identity
+          //associated?: ProfileAssociated,
+          createdAt: record.createdAt
+            ? new Date(record.createdAt).toISOString()
+            : undefined,
+          //viewer?: ViewerState,
+          //labels?: ComAtprotoLabelDefs.Label[],
+          //verification?: VerificationState,
+          //status?: StatusView,
+        };
+        return result;
+      }
+      case "Detailed": {
+        const response: ViewServerTypes.AppBskyActorGetProfile.OutputSchema =
+          ((await this.resolveGetProfiles([did])) ?? [])[0];
+        return response;
+      }
+      default:
+        throw new Error("Invalid type");
+    }
+  }
 }
 
 export class ViewServerUserManager {
···
             srccol,
             suburi,
             subdid,
-            subcol
-          ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+            subcol,
+            indexedAt
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
           [
             srcUri, // full AT URI of the source record
             srcDid, // did: of the source
···
             subUri, // full AT URI of the subject (linked record)
             subDid, // did: of the subject
             subCol, // subject collection (can be inferred or passed)
+            Date.now(),
           ]
         );
       }
···
     this.db.close?.();
   }
 }
+
+async function getServiceEndpointFromIdentity(
+  did: string,
+  kind: "skylite_index" | "bsky_appview"
+): Promise<string | null> {
+  const identity = await resolveIdentity(did);
+  const declUrl = `${identity.pds}/xrpc/com.atproto.repo.getRecord?repo=${identity.did}&collection=party.whey.skylite.declaration&rkey=self`;
+
+  const data = (await cachedFetch(declUrl)) as any;
+  //if (!resp.ok) throw new Error(`Failed to fetch declaration for ${did}`);
+  //const data = await resp.json();
+
+  const svc = data?.value?.service?.find((s: any) => s.id === `#${kind}`);
+  return svc?.serviceEndpoint ?? null;
+}
+
+const cache = new QuickLRU({ maxSize: 10000 });
+
+async function getSkyliteEndpoint(did: string): Promise<string | null> {
+  if (cache.has(did)) return cache.get(did) as string;
+  for (const resolver of config.viewServer.indexPriority) {
+    try {
+      const [prefix, suffix] = resolver.split("#") as [
+        "user" | `did:web:${string}`,
+        "skylite_index" | "bsky_appview"
+      ];
+      if (prefix === "user") {
+        return await getServiceEndpointFromIdentity(did, suffix);
+      } else if (prefix.startsWith("did:web:")) {
+        // map did:web:foo.com -> https://foo.com
+        return prefix.replace("did:web:", "https://");
+      }
+    } catch (err) {
+      // continue to next resolver
+      continue;
+    }
+  }
+  return null; //throw new Error(`No endpoint found for ${resolver}`);
+}
+
+// export interface Notification {
+//     $type?: 'app.bsky.notification.listNotifications#notification';
+//     uri: string;
+//     cid: string;
+//     author: AppBskyActorDefs.ProfileView;
+//     /** The reason why this notification was delivered - e.g. your post was liked, or you received a new follower. */
+//     reason: 'like' | 'repost' | 'follow' | 'mention' | 'reply' | 'quote' | 'starterpack-joined' | 'verified' | 'unverified' | 'like-via-repost' | 'repost-via-repost' | (string & {});
+//     reasonSubject?: string;
+//     record: {
+//         [_ in string]: unknown;
+//     };
+//     isRead: boolean;
+//     indexedAt: string;
+//     labels?: ComAtprotoLabelDefs.Label[];
+// }