convex-feedback 0.2.0-beta.1 → 0.2.0-beta.3

package/src/component/admin.ts

@@ -1,9 +1,11 @@
+import { stream } from "convex-helpers/server/stream";
 import {
   paginationOptsValidator,
   paginationResultValidator,
+  type PaginationOptions,
+  type PaginationResult,
 } 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";
@@ -19,6 +21,68 @@ import {
 } from "./model.js";
 import schema from "./schema.js";
 
+const ADMIN_SEARCH_CURSOR_PREFIX = "convex-feedback:admin-search:";
+
+type TakeQuery<T> = {
+  take(n: number): Promise<T[]>;
+};
+
+function encodeAdminSearchCursor(offset: number): string {
+  return `${ADMIN_SEARCH_CURSOR_PREFIX}${offset}`;
+}
+
+function decodeAdminSearchCursor(cursor: string | null | undefined): number {
+  if (cursor === null || cursor === undefined) return 0;
+  if (!cursor.startsWith(ADMIN_SEARCH_CURSOR_PREFIX)) {
+    throw new ConvexError("InvalidCursor: invalid admin search cursor.");
+  }
+
+  const offset = Number(cursor.slice(ADMIN_SEARCH_CURSOR_PREFIX.length));
+  if (!Number.isSafeInteger(offset) || offset < 0) {
+    throw new ConvexError("InvalidCursor: invalid admin search cursor.");
+  }
+  return offset;
+}
+
+function addAdminSearchCursorOffsets(left: number, right: number): number {
+  const result = left + right;
+  if (!Number.isSafeInteger(result) || result < 0) {
+    throw new ConvexError("InvalidCursor: admin search cursor is too large.");
+  }
+  return result;
+}
+
+async function paginateAdminSearchIndex(
+  query: TakeQuery<Doc<"entries">>,
+  paginationOpts: PaginationOptions,
+): Promise<PaginationResult<Doc<"entries">>> {
+  const start = decodeAdminSearchCursor(paginationOpts.cursor);
+  const end = decodeAdminSearchCursor(paginationOpts.endCursor);
+  const requestedEnd =
+    paginationOpts.endCursor === undefined || paginationOpts.endCursor === null
+      ? addAdminSearchCursorOffsets(start, paginationOpts.numItems)
+      : end;
+
+  if (requestedEnd < start) {
+    throw new ConvexError("InvalidCursor: admin search cursors are reversed.");
+  }
+
+  // Search-index queries cannot expose a component-safe continuation cursor.
+  // Read through the requested range and use the result offset as our opaque
+  // cursor instead.
+  const results = await query.take(
+    addAdminSearchCursorOffsets(requestedEnd, 1),
+  );
+  const page = results.slice(start, requestedEnd);
+  const nextOffset = addAdminSearchCursorOffsets(start, page.length);
+
+  return {
+    page,
+    isDone: results.length <= requestedEnd,
+    continueCursor: encodeAdminSearchCursor(nextOffset),
+  };
+}
+
 function matchesFilters(
   entry: Doc<"entries">,
   kinds: EntryKind[] | undefined,
@@ -127,9 +191,8 @@ export const searchEntries = query({
     const canUseSearchIndex = kinds === undefined || kinds.length === 1;
 
     const result = canUseSearchIndex
-      ? await ctx.db
-          .query("entries")
-          .withSearchIndex("search", (q) => {
+      ? await paginateAdminSearchIndex(
+          ctx.db.query("entries").withSearchIndex("search", (q) => {
             const searched = q.search("searchText", searchQuery);
             const withKind =
               kinds?.length === 1 ? searched.eq("kind", kinds[0]!) : searched;
@@ -140,8 +203,9 @@ export const searchEntries = query({
             return args.priority === undefined
               ? withStatus
               : withStatus.eq("priority", args.priority);
-          })
-          .paginate(args.paginationOpts)
+          }),
+          args.paginationOpts,
+        )
       : await (
           args.priority !== undefined
             ? stream(ctx.db, schema)

package/src/component/entries.ts

@@ -609,6 +609,7 @@ export const update = mutation({
   args: {
     actor: actorValidator,
     entryId: v.id("entries"),
+    kind: v.optional(entryKindValidator),
     title: v.string(),
     body: v.string(),
     editableByAuthor: v.boolean(),
@@ -625,6 +626,11 @@ export const update = mutation({
       actorIsAdmin(args.actor) ||
       (args.editableByAuthor && entry.actorId === args.actor.id);
     if (!canEdit) throw new ConvexError("Not authorized to edit this entry.");
+    if (args.kind !== undefined && args.kind !== entry.kind) {
+      if (!actorIsAdmin(args.actor)) {
+        throw new ConvexError("Admin access is required to change entry kind.");
+      }
+    }
 
     const title = normalizeRequiredText(
       args.title,
@@ -634,6 +640,7 @@ export const update = mutation({
     const body = normalizeRequiredText(args.body, "Body", args.maxBodyLength);
 
     await ctx.db.patch("entries", args.entryId, {
+      kind: args.kind ?? entry.kind,
       title,
       body,
       normalizedTitle: normalizeTitle(title),

package/src/component/roadmap.ts

@@ -1,3 +1,4 @@
+import { paginator } from "convex-helpers/server/pagination";
 import {
   paginationOptsValidator,
   paginationResultValidator,
@@ -21,6 +22,7 @@ import {
   roadmapStatusValidator,
 } from "./model.js";
 import type { RoadmapStatus } from "./model.js";
+import schema from "./schema.js";
 
 const POSITION_STEP = 1_000_000;
 const REBALANCE_GAP_THRESHOLD = 10;
@@ -128,13 +130,14 @@ export const list = query({
   },
   returns: paginationResultValidator(roadmapItemValidator),
   handler: async (ctx, args) => {
+    const db = paginator(ctx.db, schema);
     const status = args.status;
     const state =
       status === undefined ? null : await getRebalanceState(ctx, status);
     const visibleGeneration = state?.visibleGeneration;
     const roadmapQuery =
       status !== undefined && visibleGeneration !== undefined
-        ? ctx.db
+        ? db
             .query("roadmap")
             .withIndex("by_status_deleting_at_rebalance_id_position", (q) =>
               q
@@ -143,12 +146,12 @@ export const list = query({
                 .eq("rebalanceId", visibleGeneration),
             )
         : status === undefined
-          ? ctx.db
+          ? db
               .query("roadmap")
               .withIndex("by_deleting_at_and_position", (q) =>
                 q.eq("deletingAt", undefined),
               )
-          : ctx.db
+          : db
               .query("roadmap")
               .withIndex("by_status_deleting_at_position", (q) =>
                 q.eq("status", status).eq("deletingAt", undefined),
@@ -348,11 +351,12 @@ export const rebalanceBatch = internalMutation({
   },
   returns: v.null(),
   handler: async (ctx, args) => {
+    const db = paginator(ctx.db, schema);
     const state = await getRebalanceState(ctx, args.status);
     if (state?.activeGeneration !== args.rebalanceId) return null;
 
     if (args.phase === "mark") {
-      const result = await ctx.db
+      const result = await db
         .query("roadmap")
         .withIndex("by_status_deleting_at_position", (q) =>
           q.eq("status", args.status).eq("deletingAt", undefined),
@@ -391,7 +395,7 @@ export const rebalanceBatch = internalMutation({
       return null;
     }
 
-    const result = await ctx.db
+    const result = await db
       .query("roadmap")
       .withIndex("by_status_rebalance_rank", (q) =>
         q.eq("status", args.status).eq("rebalanceId", args.rebalanceId),
@@ -610,7 +614,8 @@ export const listFeedback = query({
   },
   returns: paginationResultValidator(publicEntryValidator),
   handler: async (ctx, args) => {
-    const result = await ctx.db
+    const db = paginator(ctx.db, schema);
+    const result = await db
       .query("entries")
       .withIndex("by_roadmap_id", (q) => q.eq("roadmapId", args.roadmapId))
       .order("desc")