convex-feedback 0.2.0-beta.8 → 0.2.0

package/dist/component/entries.js

@@ -2,15 +2,30 @@ import { paginator } from "convex-helpers/server/pagination";
 import { paginationOptsValidator, paginationResultValidator, } from "convex/server";
 import { ConvexError, v } from "convex/values";
 import { mergedStream, stream } from "convex-helpers/server/stream";
-import { mutation, query } from "./_generated/server.js";
-import { assertActorId, normalizeRequiredText, normalizeTitle, serializeEntry, validateFeedbackMetadata, } from "./helpers.js";
-import { actorValidator, actorIsAdmin, entryKindValidator, entryPriorityValidator, entrySortValidator, entryStatusFilterForStatus, entryStatusFilterValidator, entryStatusValidator, feedbackMetadataValidator, publicEntryValidator, similarEntriesValidator, } from "./model.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, entryPriorityValidator, entrySortValidator, entryStatusFilterForStatus, entryStatusFilterValidator, entryStatusValidator, feedbackMetadataValidator, publicEntryValidator, similarEntriesValidator, } from "./model.js";
 import schema from "./schema.js";
 const allEntryKinds = [
     "feedback",
     "feature_request",
     "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) {
+    return Promise.resolve(entry.deletingAt === undefined);
+}
+async function scheduleEntryCleanup(ctx, entryId) {
+    await ctx.scheduler.runAfter(0, internal.entries.removeBatch, { entryId });
+}
 function normalizeKindFilter(kinds) {
     if (kinds === undefined) {
         return undefined;
@@ -52,11 +67,13 @@ export const list = query({
                             .query("entries")
                             .withIndex("by_status_filter_upvotes", (q) => q.eq("statusFilter", statusFilter))
                             .order("desc")
+                            .filterWith(entryIsLive)
                             .paginate(args.paginationOpts)
                         : await db
                             .query("entries")
                             .withIndex("by_status_filter", (q) => q.eq("statusFilter", statusFilter))
                             .order("desc")
+                            .filterWith(entryIsLive)
                             .paginate(args.paginationOpts);
             }
             else if (kinds.length === 1) {
@@ -70,11 +87,13 @@ export const list = query({
                             .query("entries")
                             .withIndex("by_kind_status_filter_upvotes", (q) => q.eq("kind", kind).eq("statusFilter", statusFilter))
                             .order("desc")
+                            .filterWith(entryIsLive)
                             .paginate(args.paginationOpts)
                         : await db
                             .query("entries")
                             .withIndex("by_kind_status_filter", (q) => q.eq("kind", kind).eq("statusFilter", statusFilter))
                             .order("desc")
+                            .filterWith(entryIsLive)
                             .paginate(args.paginationOpts);
             }
             else {
@@ -83,10 +102,12 @@ export const list = query({
                         .query("entries")
                         .withIndex("by_kind_status_filter_upvotes", (q) => 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(streams, args.sort === "top"
                     ? ["upvoteCount", "_creationTime"]
                     : ["_creationTime"]).paginate(args.paginationOpts);
@@ -100,21 +121,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) {
@@ -129,22 +154,26 @@ 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")
                             .withIndex("by_kind_status_upvotes", (q) => 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")
                             .withIndex("by_kind_status", (q) => q.eq("kind", kind).eq("status", status))
                             .order("desc")
+                            .filterWith(entryIsLive)
                             .paginate(args.paginationOpts);
         }
         else if (args.sort === "top") {
@@ -152,7 +181,8 @@ export const list = query({
                 const streams = kinds.map((kind) => 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, [
                     "upvoteCount",
                     "_creationTime",
@@ -162,7 +192,8 @@ export const list = query({
                 const streams = kinds.map((kind) => stream(ctx.db, schema)
                     .query("entries")
                     .withIndex("by_kind_status_upvotes", (q) => q.eq("kind", kind).eq("status", status))
-                    .order("desc"));
+                    .order("desc")
+                    .filterWith(entryIsLive));
                 result = await mergedStream(streams, [
                     "upvoteCount",
                     "_creationTime",
@@ -173,14 +204,16 @@ export const list = query({
             const streams = kinds.map((kind) => 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(args.paginationOpts);
         }
         else {
             const streams = kinds.map((kind) => stream(ctx.db, schema)
                 .query("entries")
                 .withIndex("by_kind_status", (q) => q.eq("kind", kind).eq("status", status))
-                .order("desc"));
+                .order("desc")
+                .filterWith(entryIsLive));
             result = await mergedStream(streams, ["_creationTime"]).paginate(args.paginationOpts);
         }
         return {
@@ -189,6 +222,36 @@ 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"),
@@ -198,7 +261,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, entry, args.viewerActorId, args.viewerIsAdmin === true);
     },
@@ -230,7 +293,8 @@ export const search = query({
                     .query("entries")
                     .withSearchIndex("search", (q) => q
                     .search("searchText", searchQuery)
-                    .eq("statusFilter", statusFilter))
+                    .eq("statusFilter", statusFilter)
+                    .eq("deletingAt", undefined))
                     .take(args.limit);
             }
             else if (kinds.length === 1) {
@@ -243,7 +307,8 @@ export const search = query({
                     .withSearchIndex("search", (q) => q
                     .search("searchText", searchQuery)
                     .eq("kind", kind)
-                    .eq("statusFilter", statusFilter))
+                    .eq("statusFilter", statusFilter)
+                    .eq("deletingAt", undefined))
                     .take(args.limit);
             }
             else {
@@ -256,7 +321,8 @@ export const search = query({
                     .query("entries")
                     .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) => q.or(q.eq(q.field("kind"), firstKind), q.eq(q.field("kind"), secondKind)))
                     .take(args.limit);
@@ -267,11 +333,14 @@ export const search = query({
                 status === undefined
                     ? await ctx.db
                         .query("entries")
-                        .withSearchIndex("search", (q) => q.search("searchText", searchQuery))
+                        .withSearchIndex("search", (q) => 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))
+                        .withSearchIndex("search", (q) => q
+                        .search("searchText", searchQuery)
+                        .eq("status", status)
+                        .eq("deletingAt", undefined))
                         .take(args.limit);
         }
         else if (kinds.length === 1) {
@@ -283,14 +352,18 @@ export const search = query({
                 status === undefined
                     ? await ctx.db
                         .query("entries")
-                        .withSearchIndex("search", (q) => q.search("searchText", searchQuery).eq("kind", kind))
+                        .withSearchIndex("search", (q) => q
+                        .search("searchText", searchQuery)
+                        .eq("kind", kind)
+                        .eq("deletingAt", undefined))
                         .take(args.limit)
                     : await ctx.db
                         .query("entries")
                         .withSearchIndex("search", (q) => q
                         .search("searchText", searchQuery)
                         .eq("kind", kind)
-                        .eq("status", status))
+                        .eq("status", status)
+                        .eq("deletingAt", undefined))
                         .take(args.limit);
         }
         else {
@@ -302,16 +375,21 @@ export const search = query({
             const searchResults = status === undefined
                 ? ctx.db
                     .query("entries")
-                    .withSearchIndex("search", (q) => q.search("searchText", searchQuery))
+                    .withSearchIndex("search", (q) => q.search("searchText", searchQuery).eq("deletingAt", undefined))
                 : ctx.db
                     .query("entries")
-                    .withSearchIndex("search", (q) => q.search("searchText", searchQuery).eq("status", status));
+                    .withSearchIndex("search", (q) => q
+                    .search("searchText", searchQuery)
+                    .eq("status", status)
+                    .eq("deletingAt", undefined));
             entries = await searchResults
                 // eslint-disable-next-line @convex-dev/no-filter-in-query
                 .filter((q) => q.or(q.eq(q.field("kind"), firstKind), q.eq(q.field("kind"), secondKind)))
                 .take(args.limit);
         }
-        return await Promise.all(entries.map((entry) => serializeEntry(ctx, entry, args.viewerActorId)));
+        return await Promise.all(entries
+            .filter((entry) => entry.deletingAt === undefined)
+            .map((entry) => serializeEntry(ctx, entry, args.viewerActorId)));
     },
 });
 export const similar = query({
@@ -347,10 +425,16 @@ export const similar = query({
                 ? await ctx.db
                     .query("entries")
                     .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(exactDocs.map((entry) => serializeEntry(ctx, entry, args.viewerActorId)));
         const remainingLimit = args.limit - exactDocs.length;
@@ -374,11 +458,14 @@ export const similar = query({
         const similarDocs = kind === undefined
             ? await ctx.db
                 .query("entries")
-                .withSearchIndex("search", (q) => q.search("searchText", searchText))
+                .withSearchIndex("search", (q) => q.search("searchText", searchText).eq("deletingAt", undefined))
                 .take(candidateLimit)
             : await ctx.db
                 .query("entries")
-                .withSearchIndex("search", (q) => q.search("searchText", searchText).eq("kind", kind))
+                .withSearchIndex("search", (q) => q
+                .search("searchText", searchText)
+                .eq("kind", kind)
+                .eq("deletingAt", undefined))
                 .take(candidateLimit);
         const similarDocsWithoutExactMatches = similarDocs
             .filter((entry) => !exactIds.has(entry._id))
@@ -400,8 +487,22 @@ 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)) {
@@ -427,7 +528,22 @@ export const create = mutation({
             actorId: args.actorId,
             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,
+            },
+        };
     },
 });
 export const update = mutation({
@@ -447,6 +563,9 @@ export const update = mutation({
         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) ||
             (args.editableByAuthor && entry.actorId === args.actor.id);
         if (!canEdit)
@@ -470,6 +589,131 @@ export const update = mutation({
         return null;
     },
 });
+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,
@@ -481,9 +725,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),
@@ -503,9 +751,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(),
@@ -518,13 +770,39 @@ 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")
             .withIndex("by_entry_actor", (q) => q.eq("entryId", args.entryId).eq("actorId", args.actorId))
@@ -539,7 +817,23 @@ export const setUpvote = mutation({
                 upvoteCount,
                 statusFilter: entryStatusFilterForStatus(entry.status),
             });
-            return { active: true, upvoteCount };
+            if (!args.includeCallbackContext) {
+                return { active: true, upvoteCount };
+            }
+            return {
+                changed: true,
+                active: true,
+                transition: "added",
+                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) {
             await ctx.db.delete("reactions", existing._id);
@@ -548,9 +842,34 @@ export const setUpvote = mutation({
                 upvoteCount,
                 statusFilter: entryStatusFilterForStatus(entry.status),
             });
-            return { active: false, upvoteCount };
+            if (!args.includeCallbackContext) {
+                return { active: false, upvoteCount };
+            }
+            return {
+                changed: true,
+                active: false,
+                transition: "removed",
+                previousCount: entry.upvoteCount,
+                count: upvoteCount,
+                entry: {
+                    id: entry._id,
+                    actorId: entry.actorId,
+                    kind: entry.kind,
+                    status: entry.status,
+                    title: entry.title,
+                },
+            };
+        }
+        if (!args.includeCallbackContext) {
+            return { active: args.desiredState, upvoteCount: entry.upvoteCount };
         }
-        return { active: args.desiredState, upvoteCount: entry.upvoteCount };
+        return {
+            changed: false,
+            active: args.desiredState,
+            transition: null,
+            previousCount: entry.upvoteCount,
+            count: entry.upvoteCount,
+        };
     },
 });
 //# sourceMappingURL=entries.js.map