convex-feedback 0.2.0-beta.8 → 0.2.0

package/src/component/entries.ts

@@ -8,15 +8,18 @@ import { ConvexError, v } from "convex/values";
 
 import { mergedStream, stream } from "convex-helpers/server/stream";
 import type { Doc } from "./_generated/dataModel.js";
-import { mutation, query } from "./_generated/server.js";
+import { internal } from "./_generated/api.js";
+import { internalMutation, mutation, query } from "./_generated/server.js";
 import {
   assertActorId,
   normalizeRequiredText,
   normalizeTitle,
+  serializeActivityEntry,
   serializeEntry,
   validateFeedbackMetadata,
 } from "./helpers.js";
 import {
+  activityEntryWithContextValidator,
   actorValidator,
   actorIsAdmin,
   entryKindValidator,
@@ -31,6 +34,7 @@ import {
   type EntryKind,
 } from "./model.js";
 import schema from "./schema.js";
+import type { MutationCtx } from "./types.js";
 
 const allEntryKinds: readonly EntryKind[] = [
   "feedback",
@@ -38,6 +42,26 @@ const allEntryKinds: readonly EntryKind[] = [
   "bug_report",
 ];
 
+/**
+ * Cleanup deliberately uses small bounded batches. A comment may have more
+ * reactions than this limit, so its reactions are drained over multiple
+ * scheduled transactions before the comment itself is removed.
+ */
+const deletionBatchSize = 100;
+const commentDeletionBatchSize = 25;
+const reactionDeletionBatchSize = 100;
+
+function entryIsLive(entry: Doc<"entries">): Promise<boolean> {
+  return Promise.resolve(entry.deletingAt === undefined);
+}
+
+async function scheduleEntryCleanup(
+  ctx: MutationCtx,
+  entryId: Doc<"entries">["_id"],
+): Promise<void> {
+  await ctx.scheduler.runAfter(0, internal.entries.removeBatch, { entryId });
+}
+
 function normalizeKindFilter(
   kinds: readonly EntryKind[] | undefined,
 ): EntryKind[] | undefined {
@@ -95,6 +119,7 @@ export const list = query({
                   q.eq("statusFilter", statusFilter),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
             : await db
                 .query("entries")
@@ -102,6 +127,7 @@ export const list = query({
                   q.eq("statusFilter", statusFilter),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts);
       } else if (kinds.length === 1) {
         const kind = kinds[0];
@@ -118,6 +144,7 @@ export const list = query({
                   q.eq("kind", kind).eq("statusFilter", statusFilter),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
             : await db
                 .query("entries")
@@ -125,6 +152,7 @@ export const list = query({
                   q.eq("kind", kind).eq("statusFilter", statusFilter),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts);
       } else {
         const streams = kinds.map((kind) =>
@@ -135,12 +163,14 @@ export const list = query({
                   q.eq("kind", kind).eq("statusFilter", statusFilter),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
             : stream(ctx.db, schema)
                 .query("entries")
                 .withIndex("by_kind_status_filter", (q) =>
                   q.eq("kind", kind).eq("statusFilter", statusFilter),
                 )
-                .order("desc"),
+                .order("desc")
+                .filterWith(entryIsLive),
         );
 
         result = await mergedStream(
@@ -158,21 +188,25 @@ export const list = query({
                 .query("entries")
                 .withIndex("by_upvotes")
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
             : await db
                 .query("entries")
                 .withIndex("by_status_upvotes", (q) => q.eq("status", status))
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
           : status === undefined
             ? await db
                 .query("entries")
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
             : await db
                 .query("entries")
                 .withIndex("by_status", (q) => q.eq("status", status))
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts);
     } else if (kinds.length === 1) {
       const kind = kinds[0];
@@ -188,6 +222,7 @@ export const list = query({
                 .query("entries")
                 .withIndex("by_kind_upvotes", (q) => q.eq("kind", kind))
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
             : await db
                 .query("entries")
@@ -195,12 +230,14 @@ export const list = query({
                   q.eq("kind", kind).eq("status", status),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
           : status === undefined
             ? await db
                 .query("entries")
                 .withIndex("by_kind", (q) => q.eq("kind", kind))
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts)
             : await db
                 .query("entries")
@@ -208,6 +245,7 @@ export const list = query({
                   q.eq("kind", kind).eq("status", status),
                 )
                 .order("desc")
+                .filterWith(entryIsLive)
                 .paginate(args.paginationOpts);
     } else if (args.sort === "top") {
       if (status === undefined) {
@@ -215,7 +253,8 @@ export const list = query({
           stream(ctx.db, schema)
             .query("entries")
             .withIndex("by_kind_upvotes", (q) => q.eq("kind", kind))
-            .order("desc"),
+            .order("desc")
+            .filterWith(entryIsLive),
         );
 
         result = await mergedStream(streams, [
@@ -229,7 +268,8 @@ export const list = query({
             .withIndex("by_kind_status_upvotes", (q) =>
               q.eq("kind", kind).eq("status", status),
             )
-            .order("desc"),
+            .order("desc")
+            .filterWith(entryIsLive),
         );
 
         result = await mergedStream(streams, [
@@ -242,7 +282,8 @@ export const list = query({
         stream(ctx.db, schema)
           .query("entries")
           .withIndex("by_kind", (q) => q.eq("kind", kind))
-          .order("desc"),
+          .order("desc")
+          .filterWith(entryIsLive),
       );
 
       result = await mergedStream(streams, ["_creationTime"]).paginate(
@@ -255,7 +296,8 @@ export const list = query({
           .withIndex("by_kind_status", (q) =>
             q.eq("kind", kind).eq("status", status),
           )
-          .order("desc"),
+          .order("desc")
+          .filterWith(entryIsLive),
       );
 
       result = await mergedStream(streams, ["_creationTime"]).paginate(
@@ -274,6 +316,43 @@ export const list = query({
   },
 });
 
+/**
+ * List entries created by a known actor. This component-level query remains
+ * actor-parameterized so trusted host/server consumers can use it without a
+ * request authentication context.
+ *
+ * `includeAdminContext` is intentionally unavailable on the host-facing
+ * `listUserEntries` wrapper. Trusted server consumers such as exports may opt
+ * into retained metadata and triage context when needed.
+ */
+export const listByActor = query({
+  args: {
+    paginationOpts: paginationOptsValidator,
+    actorId: v.string(),
+    includeAdminContext: v.optional(v.boolean()),
+  },
+  returns: paginationResultValidator(activityEntryWithContextValidator),
+  handler: async (ctx, args) => {
+    assertActorId(args.actorId);
+
+    const result = await stream(ctx.db, schema)
+      .query("entries")
+      .withIndex("by_actor", (q) => q.eq("actorId", args.actorId))
+      .order("desc")
+      .filterWith(entryIsLive)
+      .paginate(args.paginationOpts);
+
+    return {
+      ...result,
+      page: await Promise.all(
+        result.page.map((entry) =>
+          serializeActivityEntry(ctx, entry, args.includeAdminContext === true),
+        ),
+      ),
+    };
+  },
+});
+
 export const get = query({
   args: {
     entryId: v.id("entries"),
@@ -283,7 +362,7 @@ export const get = query({
   returns: v.union(publicEntryValidator, v.null()),
   handler: async (ctx, args) => {
     const entry = await ctx.db.get("entries", args.entryId);
-    return entry === null
+    return entry === null || entry.deletingAt !== undefined
       ? null
       : serializeEntry(
           ctx,
@@ -329,7 +408,8 @@ export const search = query({
           .withSearchIndex("search", (q) =>
             q
               .search("searchText", searchQuery)
-              .eq("statusFilter", statusFilter),
+              .eq("statusFilter", statusFilter)
+              .eq("deletingAt", undefined),
           )
           .take(args.limit);
       } else if (kinds.length === 1) {
@@ -345,7 +425,8 @@ export const search = query({
             q
               .search("searchText", searchQuery)
               .eq("kind", kind)
-              .eq("statusFilter", statusFilter),
+              .eq("statusFilter", statusFilter)
+              .eq("deletingAt", undefined),
           )
           .take(args.limit);
       } else {
@@ -361,7 +442,8 @@ export const search = query({
           .withSearchIndex("search", (q) =>
             q
               .search("searchText", searchQuery)
-              .eq("statusFilter", statusFilter),
+              .eq("statusFilter", statusFilter)
+              .eq("deletingAt", undefined),
           )
           // eslint-disable-next-line @convex-dev/no-filter-in-query
           .filter((q) =>
@@ -378,13 +460,16 @@ export const search = query({
           ? await ctx.db
               .query("entries")
               .withSearchIndex("search", (q) =>
-                q.search("searchText", searchQuery),
+                q.search("searchText", searchQuery).eq("deletingAt", undefined),
               )
               .take(args.limit)
           : await ctx.db
               .query("entries")
               .withSearchIndex("search", (q) =>
-                q.search("searchText", searchQuery).eq("status", status),
+                q
+                  .search("searchText", searchQuery)
+                  .eq("status", status)
+                  .eq("deletingAt", undefined),
               )
               .take(args.limit);
     } else if (kinds.length === 1) {
@@ -399,7 +484,10 @@ export const search = query({
           ? await ctx.db
               .query("entries")
               .withSearchIndex("search", (q) =>
-                q.search("searchText", searchQuery).eq("kind", kind),
+                q
+                  .search("searchText", searchQuery)
+                  .eq("kind", kind)
+                  .eq("deletingAt", undefined),
               )
               .take(args.limit)
           : await ctx.db
@@ -408,7 +496,8 @@ export const search = query({
                 q
                   .search("searchText", searchQuery)
                   .eq("kind", kind)
-                  .eq("status", status),
+                  .eq("status", status)
+                  .eq("deletingAt", undefined),
               )
               .take(args.limit);
     } else {
@@ -424,12 +513,15 @@ export const search = query({
           ? ctx.db
               .query("entries")
               .withSearchIndex("search", (q) =>
-                q.search("searchText", searchQuery),
+                q.search("searchText", searchQuery).eq("deletingAt", undefined),
               )
           : ctx.db
               .query("entries")
               .withSearchIndex("search", (q) =>
-                q.search("searchText", searchQuery).eq("status", status),
+                q
+                  .search("searchText", searchQuery)
+                  .eq("status", status)
+                  .eq("deletingAt", undefined),
               );
 
       entries = await searchResults
@@ -444,7 +536,9 @@ export const search = query({
     }
 
     return await Promise.all(
-      entries.map((entry) => serializeEntry(ctx, entry, args.viewerActorId)),
+      entries
+        .filter((entry) => entry.deletingAt === undefined)
+        .map((entry) => serializeEntry(ctx, entry, args.viewerActorId)),
     );
   },
 });
@@ -489,12 +583,18 @@ export const similar = query({
               .withIndex("by_normalized_title", (q) =>
                 q.eq("normalizedTitle", normalizedTitle),
               )
+              // The deletion flag is not part of this exact-match index.
+              // Filter before take so pending entries cannot consume a slot.
+              // eslint-disable-next-line @convex-dev/no-filter-in-query
+              .filter((q) => q.eq(q.field("deletingAt"), undefined))
               .take(args.limit)
           : await ctx.db
               .query("entries")
               .withIndex("by_kind_normalized_title", (q) =>
                 q.eq("kind", kind).eq("normalizedTitle", normalizedTitle),
               )
+              // eslint-disable-next-line @convex-dev/no-filter-in-query
+              .filter((q) => q.eq(q.field("deletingAt"), undefined))
               .take(args.limit);
 
     const exact = await Promise.all(
@@ -530,13 +630,16 @@ export const similar = query({
         ? await ctx.db
             .query("entries")
             .withSearchIndex("search", (q) =>
-              q.search("searchText", searchText),
+              q.search("searchText", searchText).eq("deletingAt", undefined),
             )
             .take(candidateLimit)
         : await ctx.db
             .query("entries")
             .withSearchIndex("search", (q) =>
-              q.search("searchText", searchText).eq("kind", kind),
+              q
+                .search("searchText", searchText)
+                .eq("kind", kind)
+                .eq("deletingAt", undefined),
             )
             .take(candidateLimit);
 
@@ -566,8 +669,25 @@ export const create = mutation({
     maxTitleLength: v.number(),
     maxBodyLength: v.number(),
     metadata: v.optional(feedbackMetadataValidator),
+    includeCallbackContext: v.optional(v.boolean()),
   },
-  returns: v.id("entries"),
+  returns: v.union(
+    v.object({ id: v.id("entries") }),
+    v.object({
+      id: v.id("entries"),
+      entry: v.object({
+        id: v.id("entries"),
+        actorId: v.string(),
+        kind: entryKindValidator,
+        status: entryStatusValidator,
+        title: v.string(),
+        body: v.string(),
+        metadata: v.optional(feedbackMetadataValidator),
+        upvoteCount: v.number(),
+        commentCount: v.number(),
+      }),
+    }),
+  ),
   handler: async (ctx, args) => {
     assertActorId(args.actorId);
     if (!args.enabledKinds.includes(args.kind)) {
@@ -601,7 +721,22 @@ export const create = mutation({
       entryId: entry,
     });
 
-    return entry;
+    if (!args.includeCallbackContext) return { id: entry };
+
+    return {
+      id: entry,
+      entry: {
+        id: entry,
+        actorId: args.actorId,
+        kind: args.kind,
+        status: args.defaultStatus,
+        title,
+        body,
+        ...(args.metadata === undefined ? {} : { metadata: args.metadata }),
+        upvoteCount: 1,
+        commentCount: 0,
+      },
+    };
   },
 });
 
@@ -621,6 +756,9 @@ export const update = mutation({
     assertActorId(args.actor.id);
     const entry = await ctx.db.get("entries", args.entryId);
     if (entry === null) throw new ConvexError("Entry not found.");
+    if (entry.deletingAt !== undefined) {
+      throw new ConvexError("Entry is being deleted.");
+    }
 
     const canEdit =
       actorIsAdmin(args.actor) ||
@@ -652,6 +790,150 @@ export const update = mutation({
   },
 });
 
+export const remove = mutation({
+  args: {
+    actor: actorValidator,
+    entryId: v.id("entries"),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    assertActorId(args.actor.id);
+    if (!actorIsAdmin(args.actor)) {
+      throw new ConvexError("Admin access is required to delete an entry.");
+    }
+
+    const entry = await ctx.db.get("entries", args.entryId);
+    if (entry === null) return null;
+
+    // Mark and detach in one transaction so every committed read can
+    // hide/reject the entry before scheduled cleanup removes dependents.
+    // Repeated requests are safe: they only enqueue another idempotent batch.
+    if (entry.deletingAt !== undefined) {
+      await scheduleEntryCleanup(ctx, args.entryId);
+      return null;
+    }
+
+    const now = Date.now();
+    if (entry.roadmapId !== undefined) {
+      const roadmap = await ctx.db.get("roadmap", entry.roadmapId);
+      if (roadmap !== null) {
+        await ctx.db.patch("roadmap", roadmap._id, {
+          feedbackCount: Math.max(0, roadmap.feedbackCount - 1),
+          updatedAt: now,
+        });
+      }
+    }
+
+    await ctx.db.patch("entries", args.entryId, {
+      roadmapId: undefined,
+      deletingAt: now,
+      updatedAt: now,
+    });
+    await scheduleEntryCleanup(ctx, args.entryId);
+    return null;
+  },
+});
+
+/**
+ * Remove one bounded slice of an entry's dependent documents. Direct entry
+ * reactions are drained first, then comments are processed in index order.
+ * Each comment's reactions are drained before the comment is deleted, which
+ * keeps this safe for comments with arbitrarily many likes.
+ */
+export const removeBatch = internalMutation({
+  args: { entryId: v.id("entries") },
+  returns: v.object({ processed: v.number(), hasMore: v.boolean() }),
+  handler: async (ctx, args) => {
+    const entry = await ctx.db.get("entries", args.entryId);
+    if (entry === null || entry.deletingAt === undefined) {
+      return { processed: 0, hasMore: false };
+    }
+
+    const directReactions = await ctx.db
+      .query("reactions")
+      .withIndex("by_entry_actor", (q) => q.eq("entryId", args.entryId))
+      .take(deletionBatchSize);
+    for (const reaction of directReactions) {
+      await ctx.db.delete("reactions", reaction._id);
+    }
+    if (directReactions.length === deletionBatchSize) {
+      await scheduleEntryCleanup(ctx, args.entryId);
+      return { processed: directReactions.length, hasMore: true };
+    }
+
+    const comments = await ctx.db
+      .query("comments")
+      .withIndex("by_entry_parent", (q) => q.eq("entryId", args.entryId))
+      .take(commentDeletionBatchSize);
+    let processed = directReactions.length;
+
+    for (const comment of comments) {
+      const commentReactions = await ctx.db
+        .query("reactions")
+        .withIndex("by_comment_actor", (q) => q.eq("commentId", comment._id))
+        .take(reactionDeletionBatchSize + 1);
+
+      const reactionsToDelete = commentReactions.slice(
+        0,
+        reactionDeletionBatchSize,
+      );
+      for (const reaction of reactionsToDelete) {
+        await ctx.db.delete("reactions", reaction._id);
+        processed += 1;
+      }
+
+      // Leave this comment in place until its complete reaction set has been
+      // drained. It will be the first item in the next indexed batch.
+      if (commentReactions.length > reactionDeletionBatchSize) {
+        await scheduleEntryCleanup(ctx, args.entryId);
+        return { processed, hasMore: true };
+      }
+
+      await ctx.db.delete("comments", comment._id);
+      processed += 1;
+    }
+
+    if (comments.length === commentDeletionBatchSize) {
+      await scheduleEntryCleanup(ctx, args.entryId);
+      return { processed, hasMore: true };
+    }
+
+    await ctx.scheduler.runAfter(0, internal.entries.finalizeRemoval, {
+      entryId: args.entryId,
+    });
+    return { processed, hasMore: false };
+  },
+});
+
+/** Hard-delete only after a fresh bounded dependency check. */
+export const finalizeRemoval = internalMutation({
+  args: { entryId: v.id("entries") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const entry = await ctx.db.get("entries", args.entryId);
+    if (entry === null || entry.deletingAt === undefined) return null;
+
+    const [directReaction, comment] = await Promise.all([
+      ctx.db
+        .query("reactions")
+        .withIndex("by_entry_actor", (q) => q.eq("entryId", args.entryId))
+        .first(),
+      ctx.db
+        .query("comments")
+        .withIndex("by_entry_parent", (q) => q.eq("entryId", args.entryId))
+        .first(),
+    ]);
+
+    if (directReaction !== null || comment !== null) {
+      await scheduleEntryCleanup(ctx, args.entryId);
+      return null;
+    }
+
+    await ctx.db.delete("entries", args.entryId);
+    return null;
+  },
+});
+
 export const setStatus = mutation({
   args: {
     actor: actorValidator,
@@ -663,9 +945,13 @@ export const setStatus = mutation({
     if (!actorIsAdmin(args.actor)) {
       throw new ConvexError("Admin access is required to change status.");
     }
-    if ((await ctx.db.get("entries", args.entryId)) === null) {
+    const entry = await ctx.db.get("entries", args.entryId);
+    if (entry === null) {
       throw new ConvexError("Entry not found.");
     }
+    if (entry.deletingAt !== undefined) {
+      throw new ConvexError("Entry is being deleted.");
+    }
     await ctx.db.patch("entries", args.entryId, {
       status: args.status,
       statusFilter: entryStatusFilterForStatus(args.status),
@@ -686,9 +972,13 @@ export const setPriority = mutation({
     if (!actorIsAdmin(args.actor)) {
       throw new ConvexError("Admin access is required to change priority.");
     }
-    if ((await ctx.db.get("entries", args.entryId)) === null) {
+    const entry = await ctx.db.get("entries", args.entryId);
+    if (entry === null) {
       throw new ConvexError("Entry not found.");
     }
+    if (entry.deletingAt !== undefined) {
+      throw new ConvexError("Entry is being deleted.");
+    }
     await ctx.db.patch("entries", args.entryId, {
       priority: args.priority === null ? undefined : args.priority,
       updatedAt: Date.now(),
@@ -702,12 +992,42 @@ export const setUpvote = mutation({
     actorId: v.string(),
     entryId: v.id("entries"),
     desiredState: v.boolean(),
+    includeCallbackContext: v.optional(v.boolean()),
   },
-  returns: v.object({ active: v.boolean(), upvoteCount: v.number() }),
+  returns: v.union(
+    v.object({
+      active: v.boolean(),
+      upvoteCount: v.number(),
+    }),
+    v.object({
+      changed: v.literal(false),
+      active: v.boolean(),
+      transition: v.null(),
+      previousCount: v.number(),
+      count: v.number(),
+    }),
+    v.object({
+      changed: v.literal(true),
+      active: v.boolean(),
+      transition: v.union(v.literal("added"), v.literal("removed")),
+      previousCount: v.number(),
+      count: v.number(),
+      entry: v.object({
+        id: v.id("entries"),
+        actorId: v.string(),
+        kind: entryKindValidator,
+        status: entryStatusValidator,
+        title: v.string(),
+      }),
+    }),
+  ),
   handler: async (ctx, args) => {
     assertActorId(args.actorId);
     const entry = await ctx.db.get("entries", args.entryId);
     if (entry === null) throw new ConvexError("Entry not found.");
+    if (entry.deletingAt !== undefined) {
+      throw new ConvexError("Entry is being deleted.");
+    }
 
     const existing = await ctx.db
       .query("reactions")
@@ -726,7 +1046,23 @@ export const setUpvote = mutation({
         upvoteCount,
         statusFilter: entryStatusFilterForStatus(entry.status),
       });
-      return { active: true, upvoteCount };
+      if (!args.includeCallbackContext) {
+        return { active: true, upvoteCount };
+      }
+      return {
+        changed: true as const,
+        active: true,
+        transition: "added" as const,
+        previousCount: entry.upvoteCount,
+        count: upvoteCount,
+        entry: {
+          id: entry._id,
+          actorId: entry.actorId,
+          kind: entry.kind,
+          status: entry.status,
+          title: entry.title,
+        },
+      };
     }
 
     if (!args.desiredState && existing !== null) {
@@ -736,9 +1072,34 @@ export const setUpvote = mutation({
         upvoteCount,
         statusFilter: entryStatusFilterForStatus(entry.status),
       });
-      return { active: false, upvoteCount };
+      if (!args.includeCallbackContext) {
+        return { active: false, upvoteCount };
+      }
+      return {
+        changed: true as const,
+        active: false,
+        transition: "removed" as const,
+        previousCount: entry.upvoteCount,
+        count: upvoteCount,
+        entry: {
+          id: entry._id,
+          actorId: entry.actorId,
+          kind: entry.kind,
+          status: entry.status,
+          title: entry.title,
+        },
+      };
     }
 
-    return { active: args.desiredState, upvoteCount: entry.upvoteCount };
+    if (!args.includeCallbackContext) {
+      return { active: args.desiredState, upvoteCount: entry.upvoteCount };
+    }
+    return {
+      changed: false as const,
+      active: args.desiredState,
+      transition: null,
+      previousCount: entry.upvoteCount,
+      count: entry.upvoteCount,
+    };
   },
 });