convex-feedback 0.2.0-beta.9 → 0.2.0

package/src/component/helpers.ts

@@ -4,8 +4,11 @@ import type { DataModel } from "./_generated/dataModel.js";
 import type { QueryCtx } from "./types.js";
 import type {
   AdminFeedbackEntry,
+  FeedbackActivityComment,
+  FeedbackActivityEntryWithContext,
   FeedbackComment,
   FeedbackEntry,
+  FeedbackReaction,
   RoadmapItem,
 } from "./model.js";
 
@@ -108,6 +111,35 @@ export function assertActorId(actorId: string): void {
   }
 }
 
+/**
+ * Find the nearest pending deletion in a comment's ancestor chain. The
+ * parent chain is bounded by the comment depth configured by the host, and is
+ * walked one document at a time so deletion reads stay indexed and bounded.
+ */
+export async function findDeletingComment(
+  ctx: QueryCtx,
+  comment: DataModel["comments"]["document"],
+): Promise<DataModel["comments"]["document"] | null> {
+  let current: DataModel["comments"]["document"] | null = comment;
+  let remaining = Math.max(0, comment.depth) + 1;
+  while (current !== null && remaining > 0) {
+    if (current.deletingAt !== undefined || current.deletedAt !== undefined) {
+      return current;
+    }
+    if (current.parentCommentId === undefined) return null;
+    remaining -= 1;
+    current = await ctx.db.get("comments", current.parentCommentId);
+  }
+  return null;
+}
+
+export async function commentIsLive(
+  ctx: QueryCtx,
+  comment: DataModel["comments"]["document"],
+): Promise<boolean> {
+  return (await findDeletingComment(ctx, comment)) === null;
+}
+
 export async function serializeEntry(
   ctx: QueryCtx,
   entry: DataModel["entries"]["document"],
@@ -206,15 +238,142 @@ export async function serializeComment(
       : { parentCommentId: comment.parentCommentId }),
     actorId: comment.actorId,
     depth: comment.depth,
-    body: comment.deletedAt === undefined ? comment.body : null,
+    body: comment.body,
     likeCount: comment.likeCount,
     replyCount: comment.replyCount,
     ...(comment.updatedAt === undefined
       ? {}
       : { updatedAt: comment.updatedAt }),
-    ...(comment.deletedAt === undefined
-      ? {}
-      : { deletedAt: comment.deletedAt }),
     viewerHasLiked: reaction !== null,
   };
 }
+
+/**
+ * Serialize an actor-scoped entry. Private diagnostic and triage context is
+ * available only to trusted component consumers that explicitly request it.
+ */
+export async function serializeActivityEntry(
+  ctx: QueryCtx,
+  entry: DataModel["entries"]["document"],
+  includeContext: boolean,
+): Promise<FeedbackActivityEntryWithContext> {
+  const roadmap =
+    includeContext && entry.roadmapId !== undefined
+      ? await ctx.db.get("roadmap", entry.roadmapId)
+      : null;
+
+  return {
+    id: entry._id,
+    creationTime: entry._creationTime,
+    actorId: entry.actorId,
+    kind: entry.kind,
+    status: entry.status,
+    title: entry.title,
+    body: entry.body,
+    upvoteCount: entry.upvoteCount,
+    commentCount: entry.commentCount,
+    ...(entry.updatedAt === undefined ? {} : { updatedAt: entry.updatedAt }),
+    ...(includeContext && entry.metadata === undefined
+      ? {}
+      : includeContext
+        ? { metadata: entry.metadata }
+        : {}),
+    ...(includeContext && entry.priority === undefined
+      ? {}
+      : includeContext
+        ? { priority: entry.priority }
+        : {}),
+    ...(roadmap === null || !includeContext
+      ? {}
+      : { roadmap: serializeRoadmapItem(roadmap) }),
+  };
+}
+
+/** Remove component-only diagnostic and triage context before host exposure. */
+export function stripActivityEntryContext(
+  entry: FeedbackActivityEntryWithContext,
+): Omit<FeedbackActivityEntryWithContext, "metadata" | "priority" | "roadmap"> {
+  return {
+    id: entry.id,
+    creationTime: entry.creationTime,
+    actorId: entry.actorId,
+    kind: entry.kind,
+    status: entry.status,
+    title: entry.title,
+    body: entry.body,
+    upvoteCount: entry.upvoteCount,
+    commentCount: entry.commentCount,
+    ...(entry.updatedAt === undefined ? {} : { updatedAt: entry.updatedAt }),
+  };
+}
+
+/** Serialize an actor-scoped comment using its already-loaded entry. */
+export function serializeActivityComment(
+  comment: DataModel["comments"]["document"],
+  entry: DataModel["entries"]["document"],
+): FeedbackActivityComment {
+  return {
+    id: comment._id,
+    creationTime: comment._creationTime,
+    entryId: comment.entryId,
+    entryTitle: entry.title,
+    ...(comment.parentCommentId === undefined
+      ? {}
+      : { parentCommentId: comment.parentCommentId }),
+    actorId: comment.actorId,
+    depth: comment.depth,
+    body: comment.body,
+    likeCount: comment.likeCount,
+    replyCount: comment.replyCount,
+    ...(comment.updatedAt === undefined
+      ? {}
+      : { updatedAt: comment.updatedAt }),
+  };
+}
+
+/**
+ * A reaction target loaded by the activity stream before serialization.
+ * Loading the target in the stream mapper and passing it here prevents a
+ * second read of the same entry or comment.
+ */
+export type ActivityReactionTarget =
+  | { type: "entry"; entry: DataModel["entries"]["document"] }
+  | {
+      type: "comment";
+      comment: DataModel["comments"]["document"];
+      entry: DataModel["entries"]["document"];
+    };
+
+/** Serialize a reaction using its already-loaded target context. */
+export function serializeActivityReaction(
+  reaction: DataModel["reactions"]["document"],
+  target: ActivityReactionTarget,
+): FeedbackReaction {
+  if (target.type === "entry") {
+    const { entry } = target;
+    return {
+      type: "entry_upvote",
+      id: reaction._id,
+      creationTime: reaction._creationTime,
+      entry: {
+        id: entry._id,
+        title: entry.title,
+        kind: entry.kind,
+        status: entry.status,
+      },
+    };
+  }
+
+  const { comment, entry } = target;
+  return {
+    type: "comment_like",
+    id: reaction._id,
+    creationTime: reaction._creationTime,
+    comment: {
+      id: comment._id,
+      body: comment.body,
+      entryId: comment.entryId,
+      entryTitle: entry.title,
+    },
+  };
+}

package/src/component/migrations.ts

@@ -2,9 +2,105 @@ import { v } from "convex/values";
 
 import { internal } from "./_generated/api.js";
 import { internalMutation } from "./_generated/server.js";
+import type { Doc } from "./_generated/dataModel.js";
+import { startCommentDeletion } from "./comments.js";
 import { entryStatusFilterForStatus } from "./model.js";
+import type { MutationCtx } from "./types.js";
 
 const statusFilterMigrationBatchSize = 100;
+const legacyCommentMigrationBatchSize = 25;
+const legacyReactionMigrationBatchSize = 100;
+
+type LegacyCommentMigrationPhase = "tombstones" | "comments" | "reactions";
+
+async function scheduleLegacyCommentMigration(
+  ctx: MutationCtx,
+  phase: LegacyCommentMigrationPhase,
+): Promise<void> {
+  await ctx.scheduler.runAfter(0, internal.migrations.cleanupLegacyComments, {
+    phase,
+  });
+}
+
+type CommentInspection =
+  | { kind: "valid" }
+  | { kind: "orphan" }
+  | { kind: "pending"; root: Doc<"comments"> };
+
+/**
+ * Validate a comment's parent chain without loading the same document twice.
+ * A missing parent or an entry mismatch makes the whole subtree legacy
+ * orphan data; a pending ancestor points the migration at the existing
+ * bounded subtree cleaner.
+ */
+async function inspectCommentChain(
+  ctx: MutationCtx,
+  comment: Doc<"comments">,
+  cache: Map<string, Doc<"comments"> | null>,
+): Promise<CommentInspection> {
+  let current = comment;
+  let remaining = Math.max(0, comment.depth) + 1;
+  while (remaining > 0) {
+    if (current.deletingAt !== undefined) {
+      return { kind: "pending", root: current };
+    }
+    if (current.deletedAt !== undefined) {
+      return { kind: "pending", root: current };
+    }
+    if (current.parentCommentId === undefined) {
+      return { kind: "valid" };
+    }
+
+    remaining -= 1;
+    const parentId = current.parentCommentId;
+    let parent = cache.get(parentId);
+    if (parent === undefined) {
+      parent = await ctx.db.get("comments", parentId);
+      cache.set(parentId, parent);
+    }
+    if (parent === null || parent.entryId !== comment.entryId) {
+      return { kind: "orphan" };
+    }
+    current = parent;
+  }
+
+  // A malformed cycle or an invalid depth is safer to remove than to leave
+  // permanently unreachable feedback data behind.
+  return { kind: "orphan" };
+}
+
+async function scheduleEntryCleanupOnce(
+  ctx: MutationCtx,
+  entryId: Doc<"entries">["_id"],
+  scheduled: Set<string>,
+): Promise<void> {
+  const key = String(entryId);
+  if (scheduled.has(key)) return;
+  scheduled.add(key);
+  await ctx.scheduler.runAfter(0, internal.entries.removeBatch, { entryId });
+}
+
+async function deleteLegacyReaction(
+  ctx: MutationCtx,
+  reaction: Doc<"reactions">,
+  comment: Doc<"comments"> | null,
+  entry: Doc<"entries"> | null,
+): Promise<void> {
+  await ctx.db.delete("reactions", reaction._id);
+
+  // Keep a surviving comment's denormalized count accurate when a malformed
+  // legacy reaction points at a missing entry but still names a live comment.
+  if (
+    comment !== null &&
+    entry !== null &&
+    comment.deletingAt === undefined &&
+    comment.deletedAt === undefined
+  ) {
+    await ctx.db.patch("comments", comment._id, {
+      likeCount: Math.max(0, comment.likeCount - 1),
+    });
+  }
+}
 
 /**
  * Backfills one bounded batch of legacy entries and schedules the next batch.
@@ -42,3 +138,322 @@ export const backfillStatusFilter = internalMutation({
     return { updated: entries.length, hasMore };
   },
 });
+
+/**
+ * Drain comments written by versions that used soft deletion. The migration
+ * is deliberately split into three bounded passes:
+ *
+ * 1. indexed legacy tombstones are marked for the current subtree cleaner;
+ * 2. an indexed comment sweep marks broken parent/entry references;
+ * 3. an indexed reaction sweep removes any remaining orphan reactions.
+ *
+ * Each pass schedules its continuation after committing the current batch.
+ * Re-running any phase is safe because migration markers and document deletes
+ * are idempotent, while the normal comment cleaner remains the single place
+ * that updates counters and removes descendants.
+ */
+export const cleanupLegacyComments = internalMutation({
+  args: {
+    phase: v.optional(
+      v.union(
+        v.literal("tombstones"),
+        v.literal("comments"),
+        v.literal("reactions"),
+      ),
+    ),
+  },
+  returns: v.object({
+    phase: v.union(
+      v.literal("tombstones"),
+      v.literal("comments"),
+      v.literal("reactions"),
+    ),
+    processed: v.number(),
+    hasMore: v.boolean(),
+  }),
+  handler: async (ctx, args) => {
+    const phase = args.phase ?? "tombstones";
+
+    if (phase === "tombstones") {
+      const tombstones = await ctx.db
+        .query("comments")
+        .withIndex("by_deleted_at", (q) => q.gte("deletedAt", 0))
+        .take(legacyCommentMigrationBatchSize);
+
+      const scheduledRoots = new Set<string>();
+      for (const comment of tombstones) {
+        const rootId = comment.deletionRootId ?? comment._id;
+        const root =
+          rootId === comment._id
+            ? comment
+            : await ctx.db.get("comments", rootId);
+        const deletionRoot = root ?? comment;
+        const key = String(deletionRoot._id);
+        if (scheduledRoots.has(key)) continue;
+        scheduledRoots.add(key);
+        await startCommentDeletion(
+          ctx,
+          deletionRoot,
+          deletionRoot.deletedAt ?? deletionRoot.deletingAt ?? Date.now(),
+        );
+      }
+
+      if (tombstones.length > 0) {
+        // Tombstone documents remain indexed until their scheduled cleaner
+        // finishes. Retry the same indexed pass so a short migration run also
+        // waits for those cleaners before moving to orphan discovery.
+        await scheduleLegacyCommentMigration(ctx, "tombstones");
+        return {
+          phase: "tombstones" as const,
+          processed: tombstones.length,
+          hasMore: true,
+        };
+      }
+
+      const pendingComments = await ctx.db
+        .query("comments")
+        .withIndex("by_legacy_cleanup", (q) =>
+          q.eq("legacyCleanupAt", undefined),
+        )
+        .take(1);
+      if (pendingComments.length > 0) {
+        await scheduleLegacyCommentMigration(ctx, "comments");
+        return { phase: "comments" as const, processed: 0, hasMore: true };
+      }
+
+      const pendingReactions = await ctx.db
+        .query("reactions")
+        .withIndex("by_legacy_cleanup", (q) =>
+          q.eq("legacyCleanupAt", undefined),
+        )
+        .take(1);
+      if (pendingReactions.length > 0) {
+        await scheduleLegacyCommentMigration(ctx, "reactions");
+        return { phase: "reactions" as const, processed: 0, hasMore: true };
+      }
+
+      return { phase: "reactions" as const, processed: 0, hasMore: false };
+    }
+
+    if (phase === "comments") {
+      const page = await ctx.db
+        .query("comments")
+        .withIndex("by_legacy_cleanup", (q) =>
+          q.eq("legacyCleanupAt", undefined),
+        )
+        .take(legacyCommentMigrationBatchSize);
+
+      const commentCache = new Map<string, Doc<"comments"> | null>();
+      for (const comment of page) {
+        commentCache.set(String(comment._id), comment);
+      }
+      const entryCache = new Map<string, Doc<"entries"> | null>();
+      const scheduledRoots = new Set<string>();
+      const scheduledEntries = new Set<string>();
+
+      const markRoot = async (
+        comment: Doc<"comments">,
+        deletionToken?: number,
+      ): Promise<void> => {
+        const rootId = comment.deletionRootId ?? comment._id;
+        const root =
+          rootId === comment._id
+            ? comment
+            : await ctx.db.get("comments", rootId);
+        const deletionRoot = root ?? comment;
+        const key = String(deletionRoot._id);
+        if (scheduledRoots.has(key)) return;
+        scheduledRoots.add(key);
+        await startCommentDeletion(
+          ctx,
+          deletionRoot,
+          deletionToken ??
+            deletionRoot.deletedAt ??
+            deletionRoot.deletingAt ??
+            Date.now(),
+        );
+      };
+
+      const getEntry = async (
+        entryId: Doc<"entries">["_id"],
+      ): Promise<Doc<"entries"> | null> => {
+        const key = String(entryId);
+        const cached = entryCache.get(key);
+        if (cached !== undefined) return cached;
+        const entry = await ctx.db.get("entries", entryId);
+        entryCache.set(key, entry);
+        return entry;
+      };
+
+      for (const comment of page) {
+        if (
+          comment.deletedAt !== undefined ||
+          comment.deletingAt !== undefined
+        ) {
+          await markRoot(comment, comment.deletedAt ?? comment.deletingAt);
+          continue;
+        }
+
+        const entry = await getEntry(comment.entryId);
+        if (entry === null) {
+          await markRoot(comment);
+          continue;
+        }
+        if (entry.deletingAt !== undefined) {
+          await scheduleEntryCleanupOnce(ctx, entry._id, scheduledEntries);
+          continue;
+        }
+
+        const inspection = await inspectCommentChain(
+          ctx,
+          comment,
+          commentCache,
+        );
+        if (inspection.kind === "orphan") {
+          await markRoot(comment);
+        } else if (inspection.kind === "pending") {
+          await markRoot(inspection.root);
+        } else {
+          await ctx.db.patch("comments", comment._id, {
+            legacyCleanupAt: Date.now(),
+          });
+        }
+      }
+
+      if (page.length === 0) {
+        await scheduleLegacyCommentMigration(ctx, "reactions");
+      } else {
+        await scheduleLegacyCommentMigration(ctx, "comments");
+      }
+
+      const nextPhase: "comments" | "reactions" =
+        page.length === 0 ? "reactions" : "comments";
+      return {
+        phase: nextPhase,
+        processed: page.length,
+        hasMore: true,
+      };
+    }
+
+    const page = await ctx.db
+      .query("reactions")
+      .withIndex("by_legacy_cleanup", (q) => q.eq("legacyCleanupAt", undefined))
+      .take(legacyReactionMigrationBatchSize);
+    const commentCache = new Map<string, Doc<"comments"> | null>();
+    const entryCache = new Map<string, Doc<"entries"> | null>();
+    const scheduledRoots = new Set<string>();
+    const scheduledEntries = new Set<string>();
+
+    const getComment = async (
+      commentId: Doc<"comments">["_id"],
+    ): Promise<Doc<"comments"> | null> => {
+      const key = String(commentId);
+      const cached = commentCache.get(key);
+      if (cached !== undefined) return cached;
+      const comment = await ctx.db.get("comments", commentId);
+      commentCache.set(key, comment);
+      return comment;
+    };
+    const getEntry = async (
+      entryId: Doc<"entries">["_id"],
+    ): Promise<Doc<"entries"> | null> => {
+      const key = String(entryId);
+      const cached = entryCache.get(key);
+      if (cached !== undefined) return cached;
+      const entry = await ctx.db.get("entries", entryId);
+      entryCache.set(key, entry);
+      return entry;
+    };
+    const markRoot = async (comment: Doc<"comments">): Promise<void> => {
+      const rootId = comment.deletionRootId ?? comment._id;
+      const root =
+        rootId === comment._id ? comment : await ctx.db.get("comments", rootId);
+      const deletionRoot = root ?? comment;
+      const key = String(deletionRoot._id);
+      if (scheduledRoots.has(key)) return;
+      scheduledRoots.add(key);
+      await startCommentDeletion(
+        ctx,
+        deletionRoot,
+        deletionRoot.deletedAt ?? deletionRoot.deletingAt ?? Date.now(),
+      );
+    };
+
+    for (const reaction of page) {
+      let comment: Doc<"comments"> | null = null;
+      let owningEntry: Doc<"entries"> | null = null;
+      let removeReaction = false;
+
+      if (reaction.commentId !== undefined) {
+        comment = await getComment(reaction.commentId);
+        if (comment === null) {
+          removeReaction = true;
+        } else {
+          owningEntry = await getEntry(comment.entryId);
+          if (owningEntry === null) {
+            removeReaction = true;
+            await markRoot(comment);
+          } else if (owningEntry.deletingAt !== undefined) {
+            removeReaction = true;
+            await scheduleEntryCleanupOnce(
+              ctx,
+              owningEntry._id,
+              scheduledEntries,
+            );
+          } else {
+            const inspection = await inspectCommentChain(
+              ctx,
+              comment,
+              commentCache,
+            );
+            if (inspection.kind === "orphan") {
+              removeReaction = true;
+              await markRoot(comment);
+            } else if (inspection.kind === "pending") {
+              removeReaction = true;
+              await markRoot(inspection.root);
+            }
+          }
+        }
+
+        if (reaction.entryId !== undefined) {
+          const reactionEntry = await getEntry(reaction.entryId);
+          if (
+            reactionEntry === null ||
+            (owningEntry !== null && reactionEntry._id !== owningEntry._id)
+          ) {
+            removeReaction = true;
+          }
+        }
+      } else if (reaction.entryId !== undefined) {
+        const entry = await getEntry(reaction.entryId);
+        if (entry === null) {
+          removeReaction = true;
+        } else if (entry.deletingAt !== undefined) {
+          removeReaction = true;
+          await scheduleEntryCleanupOnce(ctx, entry._id, scheduledEntries);
+        }
+      } else {
+        removeReaction = true;
+      }
+
+      if (removeReaction) {
+        await deleteLegacyReaction(ctx, reaction, comment, owningEntry);
+      } else {
+        await ctx.db.patch("reactions", reaction._id, {
+          legacyCleanupAt: Date.now(),
+        });
+      }
+    }
+
+    if (page.length > 0) {
+      await scheduleLegacyCommentMigration(ctx, "reactions");
+    }
+
+    return {
+      phase: "reactions" as const,
+      processed: page.length,
+      hasMore: page.length > 0,
+    };
+  },
+});