convex-feedback 0.1.1 → 0.1.2

package/src/component/comments.ts

@@ -22,28 +22,16 @@ import schema from "./schema.js";
 export const list = query({
   args: {
     paginationOpts: paginationOptsValidator,
-    entryId: v.string(),
-    parentCommentId: v.optional(v.string()),
+    entryId: v.id("entries"),
+    parentCommentId: v.optional(v.id("comments")),
     sort: commentSortValidator,
     viewerActorId: v.optional(v.string()),
   },
   returns: paginationResultValidator(publicCommentValidator),
   handler: async (ctx, args) => {
-    const entryId = ctx.db.normalizeId("entries", args.entryId);
-    if (entryId === null) throw new ConvexError("Entry not found.");
-
-    const parentCommentId =
-      args.parentCommentId === undefined
-        ? undefined
-        : ctx.db.normalizeId("comments", args.parentCommentId);
-
-    if (parentCommentId === null) {
-      throw new ConvexError("Parent comment not found.");
-    }
-
-    if (parentCommentId !== undefined && parentCommentId !== null) {
-      const parent = await ctx.db.get("comments", parentCommentId);
-      if (parent === null || parent.entryId !== entryId) {
+    if (args.parentCommentId !== undefined) {
+      const parent = await ctx.db.get("comments", args.parentCommentId);
+      if (parent === null || parent.entryId !== args.entryId) {
         throw new ConvexError("Parent comment not found on this entry.");
       }
     }
@@ -54,14 +42,18 @@ export const list = query({
         ? await db
             .query("comments")
             .withIndex("by_entry_parent_likes", (q) =>
-              q.eq("entryId", entryId).eq("parentCommentId", parentCommentId),
+              q
+                .eq("entryId", args.entryId)
+                .eq("parentCommentId", args.parentCommentId),
             )
             .order("desc")
             .paginate(args.paginationOpts)
         : await db
             .query("comments")
             .withIndex("by_entry_parent", (q) =>
-              q.eq("entryId", entryId).eq("parentCommentId", parentCommentId),
+              q
+                .eq("entryId", args.entryId)
+                .eq("parentCommentId", args.parentCommentId),
             )
             .order(args.sort === "newest" ? "desc" : "asc")
             .paginate(args.paginationOpts);
@@ -80,21 +72,19 @@ export const list = query({
 export const create = mutation({
   args: {
     actorId: v.string(),
-    entryId: v.string(),
-    parentCommentId: v.optional(v.string()),
+    entryId: v.id("entries"),
+    parentCommentId: v.optional(v.id("comments")),
     body: v.string(),
     maxDepth: v.number(),
     maxCommentLength: v.number(),
   },
-  returns: v.string(),
+  returns: v.id("comments"),
   handler: async (ctx, args) => {
     assertActorId(args.actorId);
     assertPositiveInteger(args.maxDepth, "Maximum comment depth");
     assertPositiveInteger(args.maxCommentLength, "Maximum comment length");
 
-    const entryId = ctx.db.normalizeId("entries", args.entryId);
-    if (entryId === null) throw new ConvexError("Entry not found.");
-    const entry = await ctx.db.get("entries", entryId);
+    const entry = await ctx.db.get("entries", args.entryId);
     if (entry === null) throw new ConvexError("Entry not found.");
 
     const body = normalizeRequiredText(
@@ -103,18 +93,10 @@ export const create = mutation({
       args.maxCommentLength,
     );
 
-    const parentCommentId =
-      args.parentCommentId === undefined
-        ? undefined
-        : ctx.db.normalizeId("comments", args.parentCommentId);
-    if (args.parentCommentId !== undefined && parentCommentId === null) {
-      throw new ConvexError("Parent comment not found.");
-    }
-
     let depth = 0;
-    if (parentCommentId !== undefined && parentCommentId !== null) {
-      const parent = await ctx.db.get("comments", parentCommentId);
-      if (parent === null || parent.entryId !== entryId) {
+    if (args.parentCommentId !== undefined) {
+      const parent = await ctx.db.get("comments", args.parentCommentId);
+      if (parent === null || parent.entryId !== args.entryId) {
         throw new ConvexError("Parent comment not found on this entry.");
       }
       depth = parent.depth + 1;
@@ -126,10 +108,10 @@ export const create = mutation({
     }
 
     const commentId = await ctx.db.insert("comments", {
-      entryId,
-      ...(parentCommentId === undefined || parentCommentId === null
+      entryId: args.entryId,
+      ...(args.parentCommentId === undefined
         ? {}
-        : { parentCommentId }),
+        : { parentCommentId: args.parentCommentId }),
       actorId: args.actorId,
       depth,
       body,
@@ -137,14 +119,14 @@ export const create = mutation({
       replyCount: 0,
     });
 
-    await ctx.db.patch("entries", entryId, {
+    await ctx.db.patch("entries", args.entryId, {
       commentCount: entry.commentCount + 1,
     });
 
-    if (parentCommentId !== undefined && parentCommentId !== null) {
-      const parent = await ctx.db.get("comments", parentCommentId);
+    if (args.parentCommentId !== undefined) {
+      const parent = await ctx.db.get("comments", args.parentCommentId);
       if (parent !== null) {
-        await ctx.db.patch("comments", parentCommentId, {
+        await ctx.db.patch("comments", args.parentCommentId, {
           replyCount: parent.replyCount + 1,
         });
       }
@@ -157,7 +139,7 @@ export const create = mutation({
 export const update = mutation({
   args: {
     actor: actorValidator,
-    commentId: v.string(),
+    commentId: v.id("comments"),
     body: v.string(),
     editableByAuthor: v.boolean(),
     maxCommentLength: v.number(),
@@ -165,9 +147,7 @@ export const update = mutation({
   returns: v.null(),
   handler: async (ctx, args) => {
     assertActorId(args.actor.id);
-    const commentId = ctx.db.normalizeId("comments", args.commentId);
-    if (commentId === null) throw new ConvexError("Comment not found.");
-    const comment = await ctx.db.get("comments", commentId);
+    const comment = await ctx.db.get("comments", args.commentId);
     if (comment === null) throw new ConvexError("Comment not found.");
     if (comment.deletedAt !== undefined) {
       throw new ConvexError("Deleted comments cannot be edited.");
@@ -183,7 +163,10 @@ export const update = mutation({
       "Comment",
       args.maxCommentLength,
     );
-    await ctx.db.patch("comments", commentId, { body, updatedAt: Date.now() });
+    await ctx.db.patch("comments", args.commentId, {
+      body,
+      updatedAt: Date.now(),
+    });
     return null;
   },
 });
@@ -191,15 +174,13 @@ export const update = mutation({
 export const remove = mutation({
   args: {
     actor: actorValidator,
-    commentId: v.string(),
+    commentId: v.id("comments"),
     deletableByAuthor: v.boolean(),
   },
   returns: v.null(),
   handler: async (ctx, args) => {
     assertActorId(args.actor.id);
-    const commentId = ctx.db.normalizeId("comments", args.commentId);
-    if (commentId === null) throw new ConvexError("Comment not found.");
-    const comment = await ctx.db.get("comments", commentId);
+    const comment = await ctx.db.get("comments", args.commentId);
     if (comment === null) throw new ConvexError("Comment not found.");
     if (comment.deletedAt !== undefined) return null;
 
@@ -210,7 +191,7 @@ export const remove = mutation({
       throw new ConvexError("Not authorized to delete this comment.");
     }
 
-    await ctx.db.patch("comments", commentId, { deletedAt: Date.now() });
+    await ctx.db.patch("comments", args.commentId, { deletedAt: Date.now() });
     return null;
   },
 });
@@ -218,15 +199,13 @@ export const remove = mutation({
 export const setLike = mutation({
   args: {
     actorId: v.string(),
-    commentId: v.string(),
+    commentId: v.id("comments"),
     desiredState: v.boolean(),
   },
   returns: v.object({ active: v.boolean(), likeCount: v.number() }),
   handler: async (ctx, args) => {
     assertActorId(args.actorId);
-    const commentId = ctx.db.normalizeId("comments", args.commentId);
-    if (commentId === null) throw new ConvexError("Comment not found.");
-    const comment = await ctx.db.get("comments", commentId);
+    const comment = await ctx.db.get("comments", args.commentId);
     if (comment === null) throw new ConvexError("Comment not found.");
     if (comment.deletedAt !== undefined) {
       throw new ConvexError("Deleted comments cannot receive likes.");
@@ -235,21 +214,24 @@ export const setLike = mutation({
     const existing = await ctx.db
       .query("reactions")
       .withIndex("by_comment_actor", (q) =>
-        q.eq("commentId", commentId).eq("actorId", args.actorId),
+        q.eq("commentId", args.commentId).eq("actorId", args.actorId),
       )
       .unique();
 
     if (args.desiredState && existing === null) {
-      await ctx.db.insert("reactions", { actorId: args.actorId, commentId });
+      await ctx.db.insert("reactions", {
+        actorId: args.actorId,
+        commentId: args.commentId,
+      });
       const likeCount = comment.likeCount + 1;
-      await ctx.db.patch("comments", commentId, { likeCount });
+      await ctx.db.patch("comments", args.commentId, { likeCount });
       return { active: true, likeCount };
     }
 
     if (!args.desiredState && existing !== null) {
       await ctx.db.delete("reactions", existing._id);
       const likeCount = Math.max(0, comment.likeCount - 1);
-      await ctx.db.patch("comments", commentId, { likeCount });
+      await ctx.db.patch("comments", args.commentId, { likeCount });
       return { active: false, likeCount };
     }
 

package/src/component/entries.ts

@@ -198,14 +198,12 @@ export const list = query({
 
 export const get = query({
   args: {
-    entryId: v.string(),
+    entryId: v.id("entries"),
     viewerActorId: v.optional(v.string()),
   },
   returns: v.union(publicEntryValidator, v.null()),
   handler: async (ctx, args) => {
-    const entryId = ctx.db.normalizeId("entries", args.entryId);
-    if (entryId === null) return null;
-    const entry = await ctx.db.get("entries", entryId);
+    const entry = await ctx.db.get("entries", args.entryId);
     return entry === null
       ? null
       : serializeEntry(ctx, entry, args.viewerActorId);
@@ -427,7 +425,7 @@ export const create = mutation({
     maxTitleLength: v.number(),
     maxBodyLength: v.number(),
   },
-  returns: v.string(),
+  returns: v.id("entries"),
   handler: async (ctx, args) => {
     assertActorId(args.actorId);
     if (!args.enabledKinds.includes(args.kind)) {
@@ -465,7 +463,7 @@ export const create = mutation({
 export const update = mutation({
   args: {
     actor: actorValidator,
-    entryId: v.string(),
+    entryId: v.id("entries"),
     title: v.string(),
     body: v.string(),
     editableByAuthor: v.boolean(),
@@ -475,9 +473,7 @@ export const update = mutation({
   returns: v.null(),
   handler: async (ctx, args) => {
     assertActorId(args.actor.id);
-    const entryId = ctx.db.normalizeId("entries", args.entryId);
-    if (entryId === null) throw new ConvexError("Entry not found.");
-    const entry = await ctx.db.get("entries", entryId);
+    const entry = await ctx.db.get("entries", args.entryId);
     if (entry === null) throw new ConvexError("Entry not found.");
 
     const canEdit =
@@ -492,7 +488,7 @@ export const update = mutation({
     );
     const body = normalizeRequiredText(args.body, "Body", args.maxBodyLength);
 
-    await ctx.db.patch("entries", entryId, {
+    await ctx.db.patch("entries", args.entryId, {
       title,
       body,
       normalizedTitle: normalizeTitle(title),
@@ -506,7 +502,7 @@ export const update = mutation({
 export const setStatus = mutation({
   args: {
     actor: actorValidator,
-    entryId: v.string(),
+    entryId: v.id("entries"),
     status: entryStatusValidator,
   },
   returns: v.null(),
@@ -514,11 +510,10 @@ export const setStatus = mutation({
     if (!args.actor.isModerator) {
       throw new ConvexError("Moderator access is required to change status.");
     }
-    const entryId = ctx.db.normalizeId("entries", args.entryId);
-    if (entryId === null || (await ctx.db.get("entries", entryId)) === null) {
+    if ((await ctx.db.get("entries", args.entryId)) === null) {
       throw new ConvexError("Entry not found.");
     }
-    await ctx.db.patch("entries", entryId, {
+    await ctx.db.patch("entries", args.entryId, {
       status: args.status,
       updatedAt: Date.now(),
     });
@@ -529,35 +524,36 @@ export const setStatus = mutation({
 export const setUpvote = mutation({
   args: {
     actorId: v.string(),
-    entryId: v.string(),
+    entryId: v.id("entries"),
     desiredState: v.boolean(),
   },
   returns: v.object({ active: v.boolean(), upvoteCount: v.number() }),
   handler: async (ctx, args) => {
     assertActorId(args.actorId);
-    const entryId = ctx.db.normalizeId("entries", args.entryId);
-    if (entryId === null) throw new ConvexError("Entry not found.");
-    const entry = await ctx.db.get("entries", entryId);
+    const entry = await ctx.db.get("entries", args.entryId);
     if (entry === null) throw new ConvexError("Entry not found.");
 
     const existing = await ctx.db
       .query("reactions")
       .withIndex("by_entry_actor", (q) =>
-        q.eq("entryId", entryId).eq("actorId", args.actorId),
+        q.eq("entryId", args.entryId).eq("actorId", args.actorId),
       )
       .unique();
 
     if (args.desiredState && existing === null) {
-      await ctx.db.insert("reactions", { actorId: args.actorId, entryId });
+      await ctx.db.insert("reactions", {
+        actorId: args.actorId,
+        entryId: args.entryId,
+      });
       const upvoteCount = entry.upvoteCount + 1;
-      await ctx.db.patch("entries", entryId, { upvoteCount });
+      await ctx.db.patch("entries", args.entryId, { upvoteCount });
       return { active: true, upvoteCount };
     }
 
     if (!args.desiredState && existing !== null) {
       await ctx.db.delete("reactions", existing._id);
       const upvoteCount = Math.max(0, entry.upvoteCount - 1);
-      await ctx.db.patch("entries", entryId, { upvoteCount });
+      await ctx.db.patch("entries", args.entryId, { upvoteCount });
       return { active: false, upvoteCount };
     }
 

package/src/react/index.ts

@@ -182,9 +182,12 @@ function positivePageSize(value: number | undefined, fallback: number): number {
  *
  * Create this once in the consuming application and reuse the returned hook
  * collection.
+ *
+ * @typeParam RateLimitResult The validated non-throwing rate-limit rejection
+ * type returned by mutation hooks. It is inferred from the supplied API.
  */
-export function createFeedbackHooks(
-  api: FeedbackPublicApi,
+export function createFeedbackHooks<RateLimitResult = never>(
+  api: FeedbackPublicApi<string | undefined, RateLimitResult>,
   options: FeedbackHooksOptions = {},
 ) {
   const entryPageSize = positivePageSize(options.entryPageSize, 20);
@@ -336,5 +339,10 @@ export function createFeedbackHooks(
  *
  * This type is intended to be passed to `FeedbackScreen` and other
  * `convex-feedback-ui` integrations.
+ *
+ * @typeParam RateLimitResult The validated non-throwing rate-limit rejection
+ * type returned by mutation hooks.
  */
-export type FeedbackHooks = ReturnType<typeof createFeedbackHooks>;
+export type FeedbackHooks<RateLimitResult = never> = ReturnType<
+  typeof createFeedbackHooks<RateLimitResult>
+>;