feat: add private following inbox

Author: giodl73-repo

convex/_generated/api.d.ts

@@ -174,6 +174,7 @@ import type * as publisherAbuseDevSeed from "../publisherAbuseDevSeed.js";
 import type * as publisherAbuseTemporalScan from "../publisherAbuseTemporalScan.js";
 import type * as publisherFollows from "../publisherFollows.js";
 import type * as publisherActivity from "../publisherActivity.js";
+import type * as publisherActivityInbox from "../publisherActivityInbox.js";
 import type * as publishers from "../publishers.js";
 import type * as rateLimits from "../rateLimits.js";
 import type * as retention from "../retention.js";
@@ -378,6 +379,7 @@ declare const fullApi: ApiFromModules<{
   publisherAbuseTemporalScan: typeof publisherAbuseTemporalScan;
   publisherFollows: typeof publisherFollows;
   publisherActivity: typeof publisherActivity;
+  publisherActivityInbox: typeof publisherActivityInbox;
   publishers: typeof publishers;
   rateLimits: typeof rateLimits;
   retention: typeof retention;

convex/lib/retentionPolicy.ts

@@ -242,6 +242,7 @@ export const RETENTION_POLICIES = {
   publisherFollows: permanent("User publisher follow preference records."),
   publisherActivity: permanent("Granular public publisher release activity events."),
   publisherActivityGroups: permanent("Coalesced public publisher release activity groups."),
+  publisherActivityInboxState: permanent("Per-user following inbox read frontiers."),
   auditLogs: permanent("Audit logs are durable compliance/security history."),
   systemSettings: permanent("Durable operator-controlled system settings."),
   skillsShCatalogControls: permanent("Durable skills.sh catalog operator controls."),

convex/publisherActivityInbox.test.ts

@@ -0,0 +1,93 @@
+/* @vitest-environment node */
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("./functions", () => ({
+  mutation: (def: { handler: unknown }) => ({ _handler: def.handler }),
+  query: (def: { handler: unknown }) => ({ _handler: def.handler }),
+}));
+vi.mock("./lib/access", () => ({ requireUser: vi.fn() }));
+
+const { requireUser } = await import("./lib/access");
+const { getMine, markSeenThrough } = await import("./publisherActivityInbox");
+
+type WrappedHandler<TArgs, TResult> = {
+  _handler: (ctx: unknown, args: TArgs) => Promise<TResult>;
+};
+
+const getMineHandler = (getMine as unknown as WrappedHandler<Record<string, never>, unknown>)
+  ._handler;
+const markSeenThroughHandler = (
+  markSeenThrough as unknown as WrappedHandler<{ groupId: string }, unknown>
+)._handler;
+
+function makeCtx({
+  group = { _id: "publisherActivityGroups:1", publisherId: "publishers:1", sortKey: "200:b" },
+  follow = { _id: "publisherFollows:1" } as { _id: string } | null,
+  state = null as null | {
+    _id: string;
+    userId: string;
+    seenThroughSortKey: string;
+    updatedAt: number;
+  },
+} = {}) {
+  const insert = vi.fn(async () => "publisherActivityInboxState:1");
+  const patch = vi.fn();
+  const query = vi.fn((table: string) => ({
+    withIndex: vi.fn((_index: string, build: (q: unknown) => unknown) => {
+      const q = { eq: vi.fn().mockReturnThis() };
+      build(q);
+      return { unique: vi.fn(async () => (table === "publisherFollows" ? follow : state)) };
+    }),
+  }));
+  return {
+    db: { get: vi.fn(async () => group), insert, patch, query },
+    insert,
+    patch,
+  };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("publisher activity inbox state", () => {
+  it("returns an empty read frontier for a new inbox", async () => {
+    vi.mocked(requireUser).mockResolvedValue({ userId: "users:1" } as never);
+    const result = await getMineHandler(makeCtx(), {});
+    expect(result).toEqual({ ok: true, seenThroughSortKey: null, updatedAt: null });
+  });
+
+  it("creates a seen-through frontier for a followed activity group", async () => {
+    vi.mocked(requireUser).mockResolvedValue({ userId: "users:1" } as never);
+    const ctx = makeCtx();
+    const result = await markSeenThroughHandler(ctx, { groupId: "publisherActivityGroups:1" });
+    expect(ctx.insert).toHaveBeenCalledWith("publisherActivityInboxState", {
+      userId: "users:1",
+      seenThroughSortKey: "200:b",
+      updatedAt: expect.any(Number),
+    });
+    expect(result).toEqual({ ok: true, seenThroughSortKey: "200:b" });
+  });
+
+  it("never moves the frontier backwards", async () => {
+    vi.mocked(requireUser).mockResolvedValue({ userId: "users:1" } as never);
+    const ctx = makeCtx({
+      state: {
+        _id: "publisherActivityInboxState:1",
+        userId: "users:1",
+        seenThroughSortKey: "300:c",
+        updatedAt: 1,
+      },
+    });
+    const result = await markSeenThroughHandler(ctx, { groupId: "publisherActivityGroups:1" });
+    expect(ctx.patch).not.toHaveBeenCalled();
+    expect(result).toEqual({ ok: true, seenThroughSortKey: "300:c" });
+  });
+
+  it("does not reveal groups from publishers the user no longer follows", async () => {
+    vi.mocked(requireUser).mockResolvedValue({ userId: "users:1" } as never);
+    const ctx = makeCtx({ follow: null });
+    await expect(
+      markSeenThroughHandler(ctx, { groupId: "publisherActivityGroups:1" }),
+    ).rejects.toThrow("Publisher activity group not found");
+    expect(ctx.insert).not.toHaveBeenCalled();
+  });
+});

convex/publisherActivityInbox.ts

@@ -0,0 +1,75 @@
+import { ConvexError, v } from "convex/values";
+import type { Doc, Id } from "./_generated/dataModel";
+import type { MutationCtx, QueryCtx } from "./_generated/server";
+import { mutation, query } from "./functions";
+import { requireUser } from "./lib/access";
+
+async function getStateForUser(ctx: QueryCtx | MutationCtx, userId: Id<"users">) {
+  return await ctx.db
+    .query("publisherActivityInboxState")
+    .withIndex("by_user", (q) => q.eq("userId", userId))
+    .unique();
+}
+
+async function requireFollowedGroup(
+  ctx: MutationCtx,
+  userId: Id<"users">,
+  groupId: Id<"publisherActivityGroups">,
+) {
+  const group = await ctx.db.get(groupId);
+  if (!group) throw new ConvexError("Publisher activity group not found");
+  const follow = await ctx.db
+    .query("publisherFollows")
+    .withIndex("by_follower_publisher", (q) =>
+      q.eq("followerUserId", userId).eq("publisherId", group.publisherId),
+    )
+    .unique();
+  if (!follow) throw new ConvexError("Publisher activity group not found");
+  return group;
+}
+
+export const getMine = query({
+  args: {},
+  handler: async (ctx) => {
+    const { userId } = await requireUser(ctx);
+    const state = await getStateForUser(ctx, userId);
+    return {
+      ok: true as const,
+      seenThroughSortKey: state?.seenThroughSortKey ?? null,
+      updatedAt: state?.updatedAt ?? null,
+    };
+  },
+});
+
+export const markSeenThrough = mutation({
+  args: { groupId: v.id("publisherActivityGroups") },
+  handler: async (ctx, args) => {
+    const { userId } = await requireUser(ctx);
+    const group = await requireFollowedGroup(ctx, userId, args.groupId);
+    const existing = await getStateForUser(ctx, userId);
+    if (existing && existing.seenThroughSortKey >= group.sortKey) {
+      return { ok: true as const, seenThroughSortKey: existing.seenThroughSortKey };
+    }
+
+    const updatedAt = Date.now();
+    if (existing) {
+      await ctx.db.patch(existing._id, { seenThroughSortKey: group.sortKey, updatedAt });
+    } else {
+      await ctx.db.insert("publisherActivityInboxState", {
+        userId,
+        seenThroughSortKey: group.sortKey,
+        updatedAt,
+      });
+    }
+    return { ok: true as const, seenThroughSortKey: group.sortKey };
+  },
+});
+
+export async function deletePublisherActivityInboxStateForUser(
+  ctx: MutationCtx,
+  userId: Id<"users">,
+) {
+  const state = (await getStateForUser(ctx, userId)) as Doc<"publisherActivityInboxState"> | null;
+  if (state) await ctx.db.delete(state._id);
+  return Boolean(state);
+}

convex/schema.ts

@@ -2992,6 +2992,12 @@ const publisherActivityGroups = defineTable({
   .index("by_publisher_and_sortKey", ["publisherId", "sortKey"])
   .index("by_publisher_and_batchKey", ["publisherId", "batchKey"]);
 
+const publisherActivityInboxState = defineTable({
+  userId: v.id("users"),
+  seenThroughSortKey: v.string(),
+  updatedAt: v.number(),
+}).index("by_user", ["userId"]);
+
 const auditLogs = defineTable({
   actorUserId: v.optional(v.id("users")),
   action: v.string(),
@@ -4232,6 +4238,7 @@ export default defineSchema({
   publisherFollows,
   publisherActivity,
   publisherActivityGroups,
+  publisherActivityInboxState,
   auditLogs,
   systemSettings,
   skillsShCatalogControls,

convex/users.test.ts

@@ -2013,6 +2013,13 @@ describe("users profile audit logs", () => {
           }),
         };
       }
+      if (table === "publisherActivityInboxState") {
+        return {
+          withIndex: () => ({
+            unique: vi.fn(async () => null),
+          }),
+        };
+      }
       if (table === "authAccounts" || table === "authSessions") {
         return {
           withIndex: () => ({

convex/users.ts

@@ -39,6 +39,7 @@ import {
   upsertReservedHandleForRightfulOwner,
 } from "./lib/reservedHandles";
 import { buildUserSearchResults } from "./lib/userSearch";
+import { deletePublisherActivityInboxStateForUser } from "./publisherActivityInbox";
 
 const DEFAULT_ROLE = "user";
 const ADMIN_HANDLE = "steipete";
@@ -368,6 +369,7 @@ async function hardDeleteSelfDeletedAccountState(
     .withIndex("by_user", (q) => q.eq("userId", user._id))
     .collect();
   for (const membership of githubOrgMemberships) await ctx.db.delete(membership._id);
+  await deletePublisherActivityInboxStateForUser(ctx, user._id);
 
   const deletedFollows = (await ctx.runMutation(
     internal.publisherFollows.deletePublisherFollowsForFollowerInternal,

src/components/Header.tsx

@@ -3,6 +3,7 @@ import { Link, useLocation, useNavigate } from "@tanstack/react-router";
 import { useQuery } from "convex/react";
 import {
   ArrowRight,
+  Bell,
   ExternalLink,
   ChevronDown,
   Command,
@@ -658,6 +659,12 @@ export default function Header() {
                       Add skill or plugin
                     </Link>
                   </DropdownMenuItem>
+                  <DropdownMenuItem asChild>
+                    <Link to="/inbox" className="flex items-center gap-2">
+                      <Bell size={14} aria-hidden="true" />
+                      Inbox
+                    </Link>
+                  </DropdownMenuItem>
                   <DropdownMenuItem asChild>
                     <Link to="/stars" className="flex items-center gap-2">
                       <Star size={14} aria-hidden="true" />