convex-feedback 0.1.5 → 0.2.0-beta.0

package/src/component/_generated/component.ts

@@ -23,6 +23,182 @@ import type { FunctionReference } from "convex/server";
  */
 export type ComponentApi<Name extends string | undefined = string | undefined> =
   {
+    admin: {
+      getEntry: FunctionReference<
+        "query",
+        "internal",
+        { entryId: string; viewerActorId: string },
+        {
+          actorId: string;
+          body: string;
+          commentCount: number;
+          creationTime: number;
+          id: string;
+          kind: "feedback" | "feature_request" | "bug_report";
+          metadata?: {
+            additional?: Record<string, string | number | boolean>;
+            standard?: Record<string, string | number | boolean>;
+          };
+          priority?: "low" | "medium" | "high";
+          roadmap?: {
+            createdAt: number;
+            creationTime: number;
+            description?: string;
+            feedbackCount: number;
+            id: string;
+            position: number;
+            status: "planned" | "in_progress" | "shipped";
+            title: string;
+            updatedAt: number;
+          };
+          status:
+            | "open"
+            | "under_review"
+            | "planned"
+            | "in_progress"
+            | "completed"
+            | "closed";
+          title: string;
+          updatedAt?: number;
+          upvoteCount: number;
+          viewerHasUpvoted: boolean;
+        } | null,
+        Name
+      >;
+      listEntries: FunctionReference<
+        "query",
+        "internal",
+        {
+          kinds?: Array<"feedback" | "feature_request" | "bug_report">;
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+          priority?: "low" | "medium" | "high";
+          status?:
+            | "open"
+            | "under_review"
+            | "planned"
+            | "in_progress"
+            | "completed"
+            | "closed";
+          viewerActorId: string;
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            actorId: string;
+            body: string;
+            commentCount: number;
+            creationTime: number;
+            id: string;
+            kind: "feedback" | "feature_request" | "bug_report";
+            metadata?: {
+              additional?: Record<string, string | number | boolean>;
+              standard?: Record<string, string | number | boolean>;
+            };
+            priority?: "low" | "medium" | "high";
+            roadmap?: {
+              createdAt: number;
+              creationTime: number;
+              description?: string;
+              feedbackCount: number;
+              id: string;
+              position: number;
+              status: "planned" | "in_progress" | "shipped";
+              title: string;
+              updatedAt: number;
+            };
+            status:
+              | "open"
+              | "under_review"
+              | "planned"
+              | "in_progress"
+              | "completed"
+              | "closed";
+            title: string;
+            updatedAt?: number;
+            upvoteCount: number;
+            viewerHasUpvoted: boolean;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        },
+        Name
+      >;
+      searchEntries: FunctionReference<
+        "query",
+        "internal",
+        {
+          kinds?: Array<"feedback" | "feature_request" | "bug_report">;
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+          priority?: "low" | "medium" | "high";
+          searchQuery: string;
+          status?:
+            | "open"
+            | "under_review"
+            | "planned"
+            | "in_progress"
+            | "completed"
+            | "closed";
+          viewerActorId: string;
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            actorId: string;
+            body: string;
+            commentCount: number;
+            creationTime: number;
+            id: string;
+            kind: "feedback" | "feature_request" | "bug_report";
+            metadata?: {
+              additional?: Record<string, string | number | boolean>;
+              standard?: Record<string, string | number | boolean>;
+            };
+            priority?: "low" | "medium" | "high";
+            roadmap?: {
+              createdAt: number;
+              creationTime: number;
+              description?: string;
+              feedbackCount: number;
+              id: string;
+              position: number;
+              status: "planned" | "in_progress" | "shipped";
+              title: string;
+              updatedAt: number;
+            };
+            status:
+              | "open"
+              | "under_review"
+              | "planned"
+              | "in_progress"
+              | "completed"
+              | "closed";
+            title: string;
+            updatedAt?: number;
+            upvoteCount: number;
+            viewerHasUpvoted: boolean;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        },
+        Name
+      >;
+    };
     comments: {
       create: FunctionReference<
         "mutation",
@@ -81,7 +257,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "mutation",
         "internal",
         {
-          actor: { id: string; isModerator: boolean };
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
           commentId: string;
           deletableByAuthor: boolean;
         },
@@ -99,7 +275,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "mutation",
         "internal",
         {
-          actor: { id: string; isModerator: boolean };
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
           body: string;
           commentId: string;
           editableByAuthor: boolean;
@@ -139,11 +315,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
       get: FunctionReference<
         "query",
         "internal",
-        {
-          entryId: string;
-          viewerActorId?: string;
-          viewerIsModerator?: boolean;
-        },
+        { entryId: string; viewerActorId?: string; viewerIsAdmin?: boolean },
         {
           actorId: string;
           body: string;
@@ -266,11 +438,22 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         }>,
         Name
       >;
+      setPriority: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          entryId: string;
+          priority: "low" | "medium" | "high" | null;
+        },
+        null,
+        Name
+      >;
       setStatus: FunctionReference<
         "mutation",
         "internal",
         {
-          actor: { id: string; isModerator: boolean };
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
           entryId: string;
           status:
             | "open"
@@ -354,7 +537,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "mutation",
         "internal",
         {
-          actor: { id: string; isModerator: boolean };
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
           body: string;
           editableByAuthor: boolean;
           entryId: string;
@@ -366,4 +549,183 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         Name
       >;
     };
+    roadmap: {
+      attachFeedback: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          entryId: string;
+          roadmapId: string;
+        },
+        null,
+        Name
+      >;
+      create: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          description?: string;
+          status: "planned" | "in_progress" | "shipped";
+          title: string;
+        },
+        string,
+        Name
+      >;
+      createForEntry: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          description?: string;
+          entryId: string;
+          status: "planned" | "in_progress" | "shipped";
+          title: string;
+        },
+        string,
+        Name
+      >;
+      detachFeedback: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          entryId: string;
+        },
+        null,
+        Name
+      >;
+      list: FunctionReference<
+        "query",
+        "internal",
+        {
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+          status?: "planned" | "in_progress" | "shipped";
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            createdAt: number;
+            creationTime: number;
+            description?: string;
+            feedbackCount: number;
+            id: string;
+            position: number;
+            status: "planned" | "in_progress" | "shipped";
+            title: string;
+            updatedAt: number;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        },
+        Name
+      >;
+      listFeedback: FunctionReference<
+        "query",
+        "internal",
+        {
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+          roadmapId: string;
+          viewerActorId?: string;
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            actorId: string;
+            body: string;
+            commentCount: number;
+            creationTime: number;
+            id: string;
+            kind: "feedback" | "feature_request" | "bug_report";
+            metadata?: {
+              additional?: Record<string, string | number | boolean>;
+              standard?: Record<string, string | number | boolean>;
+            };
+            status:
+              | "open"
+              | "under_review"
+              | "planned"
+              | "in_progress"
+              | "completed"
+              | "closed";
+            title: string;
+            updatedAt?: number;
+            upvoteCount: number;
+            viewerHasUpvoted: boolean;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        },
+        Name
+      >;
+      move: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          nextItemId?: string;
+          previousItemId?: string;
+          roadmapId: string;
+          status: "planned" | "in_progress" | "shipped";
+        },
+        number,
+        Name
+      >;
+      remove: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          roadmapId: string;
+        },
+        null,
+        Name
+      >;
+      search: FunctionReference<
+        "query",
+        "internal",
+        { limit: number; searchQuery: string },
+        Array<{
+          createdAt: number;
+          creationTime: number;
+          description?: string;
+          feedbackCount: number;
+          id: string;
+          position: number;
+          status: "planned" | "in_progress" | "shipped";
+          title: string;
+          updatedAt: number;
+        }>,
+        Name
+      >;
+      update: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          actor: { id: string; isAdmin?: boolean; isModerator?: boolean };
+          description?: string;
+          roadmapId: string;
+          title: string;
+        },
+        null,
+        Name
+      >;
+    };
   };

package/src/component/admin.ts

@@ -0,0 +1,180 @@
+import {
+  paginationOptsValidator,
+  paginationResultValidator,
+} from "convex/server";
+import { ConvexError, v } from "convex/values";
+import { stream } from "convex-helpers/server/stream";
+
+import type { Doc } from "./_generated/dataModel.js";
+import { query } from "./_generated/server.js";
+import { serializeAdminEntry } from "./helpers.js";
+import {
+  adminEntryValidator,
+  entryKindValidator,
+  entryPriorityValidator,
+  entryStatusValidator,
+  type EntryKind,
+  type EntryPriority,
+  type EntryStatus,
+} from "./model.js";
+import schema from "./schema.js";
+
+function matchesFilters(
+  entry: Doc<"entries">,
+  kinds: EntryKind[] | undefined,
+  status: EntryStatus | undefined,
+  priority: EntryPriority | undefined,
+): boolean {
+  return (
+    (kinds === undefined || kinds.includes(entry.kind)) &&
+    (status === undefined || entry.status === status) &&
+    (priority === undefined || entry.priority === priority)
+  );
+}
+
+function matchesSearch(entry: Doc<"entries">, searchQuery: string): boolean {
+  const haystack = entry.searchText.toLocaleLowerCase("en-US");
+  const terms = searchQuery
+    .toLocaleLowerCase("en-US")
+    .split(/\s+/)
+    .filter((term) => term.length > 0);
+  return terms.every((term) => haystack.includes(term));
+}
+
+export const getEntry = query({
+  args: { entryId: v.id("entries"), viewerActorId: v.string() },
+  returns: v.union(adminEntryValidator, v.null()),
+  handler: async (ctx, args) => {
+    const entry = await ctx.db.get("entries", args.entryId);
+    return entry === null
+      ? null
+      : await serializeAdminEntry(ctx, entry, args.viewerActorId);
+  },
+});
+
+export const listEntries = query({
+  args: {
+    kinds: v.optional(v.array(entryKindValidator)),
+    status: v.optional(entryStatusValidator),
+    priority: v.optional(entryPriorityValidator),
+    paginationOpts: paginationOptsValidator,
+    viewerActorId: v.string(),
+  },
+  returns: paginationResultValidator(adminEntryValidator),
+  handler: async (ctx, args) => {
+    const kinds =
+      args.kinds === undefined ? undefined : [...new Set(args.kinds)];
+    if (kinds?.length === 0) {
+      throw new ConvexError("`kinds` must contain at least one kind.");
+    }
+
+    const entriesStream =
+      args.priority !== undefined
+        ? stream(ctx.db, schema)
+            .query("entries")
+            .withIndex("by_priority", (q) => q.eq("priority", args.priority))
+        : args.status !== undefined
+          ? stream(ctx.db, schema)
+              .query("entries")
+              .withIndex("by_status", (q) => q.eq("status", args.status!))
+          : kinds?.length === 1
+            ? stream(ctx.db, schema)
+                .query("entries")
+                .withIndex("by_kind", (q) => q.eq("kind", kinds[0]!))
+            : stream(ctx.db, schema).query("entries");
+
+    const result = await entriesStream
+      .order("desc")
+      .filterWith((entry) =>
+        Promise.resolve(
+          matchesFilters(entry, kinds, args.status, args.priority),
+        ),
+      )
+      .paginate(args.paginationOpts);
+
+    return {
+      ...result,
+      page: await Promise.all(
+        result.page.map((entry) =>
+          serializeAdminEntry(ctx, entry, args.viewerActorId),
+        ),
+      ),
+    };
+  },
+});
+
+export const searchEntries = query({
+  args: {
+    searchQuery: v.string(),
+    kinds: v.optional(v.array(entryKindValidator)),
+    status: v.optional(entryStatusValidator),
+    priority: v.optional(entryPriorityValidator),
+    paginationOpts: paginationOptsValidator,
+    viewerActorId: v.string(),
+  },
+  returns: paginationResultValidator(adminEntryValidator),
+  handler: async (ctx, args) => {
+    const searchQuery = args.searchQuery.trim();
+    if (searchQuery.length === 0) {
+      return { page: [], isDone: true, continueCursor: "" };
+    }
+    const kinds =
+      args.kinds === undefined ? undefined : [...new Set(args.kinds)];
+    if (kinds?.length === 0) {
+      throw new ConvexError("`kinds` must contain at least one kind.");
+    }
+
+    const canUseSearchIndex = kinds === undefined || kinds.length === 1;
+
+    const result = canUseSearchIndex
+      ? await ctx.db
+          .query("entries")
+          .withSearchIndex("search", (q) => {
+            const searched = q.search("searchText", searchQuery);
+            const withKind =
+              kinds?.length === 1 ? searched.eq("kind", kinds[0]!) : searched;
+            const withStatus =
+              args.status === undefined
+                ? withKind
+                : withKind.eq("status", args.status);
+            return args.priority === undefined
+              ? withStatus
+              : withStatus.eq("priority", args.priority);
+          })
+          .paginate(args.paginationOpts)
+      : await (
+          args.priority !== undefined
+            ? stream(ctx.db, schema)
+                .query("entries")
+                .withIndex("by_priority", (q) =>
+                  q.eq("priority", args.priority),
+                )
+            : args.status !== undefined
+              ? stream(ctx.db, schema)
+                  .query("entries")
+                  .withIndex("by_status", (q) => q.eq("status", args.status!))
+              : kinds?.length === 1
+                ? stream(ctx.db, schema)
+                    .query("entries")
+                    .withIndex("by_kind", (q) => q.eq("kind", kinds[0]!))
+                : stream(ctx.db, schema).query("entries")
+        )
+          .order("desc")
+          .filterWith((entry) =>
+            Promise.resolve(
+              matchesFilters(entry, kinds, args.status, args.priority) &&
+                matchesSearch(entry, searchQuery),
+            ),
+          )
+          .paginate(args.paginationOpts);
+
+    return {
+      ...result,
+      page: await Promise.all(
+        result.page.map((entry) =>
+          serializeAdminEntry(ctx, entry, args.viewerActorId),
+        ),
+      ),
+    };
+  },
+});

package/src/component/comments.ts

@@ -14,6 +14,7 @@ import {
 } from "./helpers.js";
 import {
   actorValidator,
+  actorIsAdmin,
   commentSortValidator,
   entryStatusFilterForStatus,
   publicCommentValidator,
@@ -156,7 +157,7 @@ export const update = mutation({
     }
 
     const canEdit =
-      args.actor.isModerator ||
+      actorIsAdmin(args.actor) ||
       (args.editableByAuthor && comment.actorId === args.actor.id);
     if (!canEdit) throw new ConvexError("Not authorized to edit this comment.");
 
@@ -187,7 +188,7 @@ export const remove = mutation({
     if (comment.deletedAt !== undefined) return null;
 
     const canDelete =
-      args.actor.isModerator ||
+      actorIsAdmin(args.actor) ||
       (args.deletableByAuthor && comment.actorId === args.actor.id);
     if (!canDelete) {
       throw new ConvexError("Not authorized to delete this comment.");

package/src/component/entries.ts

@@ -18,7 +18,9 @@ import {
 } from "./helpers.js";
 import {
   actorValidator,
+  actorIsAdmin,
   entryKindValidator,
+  entryPriorityValidator,
   entrySortValidator,
   entryStatusFilterForStatus,
   entryStatusFilterValidator,
@@ -276,7 +278,7 @@ export const get = query({
   args: {
     entryId: v.id("entries"),
     viewerActorId: v.optional(v.string()),
-    viewerIsModerator: v.optional(v.boolean()),
+    viewerIsAdmin: v.optional(v.boolean()),
   },
   returns: v.union(publicEntryValidator, v.null()),
   handler: async (ctx, args) => {
@@ -287,7 +289,7 @@ export const get = query({
           ctx,
           entry,
           args.viewerActorId,
-          args.viewerIsModerator === true,
+          args.viewerIsAdmin === true,
         );
   },
 });
@@ -620,7 +622,7 @@ export const update = mutation({
     if (entry === null) throw new ConvexError("Entry not found.");
 
     const canEdit =
-      args.actor.isModerator ||
+      actorIsAdmin(args.actor) ||
       (args.editableByAuthor && entry.actorId === args.actor.id);
     if (!canEdit) throw new ConvexError("Not authorized to edit this entry.");
 
@@ -651,8 +653,8 @@ export const setStatus = mutation({
   },
   returns: v.null(),
   handler: async (ctx, args) => {
-    if (!args.actor.isModerator) {
-      throw new ConvexError("Moderator access is required to change status.");
+    if (!actorIsAdmin(args.actor)) {
+      throw new ConvexError("Admin access is required to change status.");
     }
     if ((await ctx.db.get("entries", args.entryId)) === null) {
       throw new ConvexError("Entry not found.");
@@ -666,6 +668,28 @@ export const setStatus = mutation({
   },
 });
 
+export const setPriority = mutation({
+  args: {
+    actor: actorValidator,
+    entryId: v.id("entries"),
+    priority: v.union(entryPriorityValidator, v.null()),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    if (!actorIsAdmin(args.actor)) {
+      throw new ConvexError("Admin access is required to change priority.");
+    }
+    if ((await ctx.db.get("entries", args.entryId)) === null) {
+      throw new ConvexError("Entry not found.");
+    }
+    await ctx.db.patch("entries", args.entryId, {
+      priority: args.priority === null ? undefined : args.priority,
+      updatedAt: Date.now(),
+    });
+    return null;
+  },
+});
+
 export const setUpvote = mutation({
   args: {
     actorId: v.string(),