convex-feedback 0.1.4 → 0.2.0-beta.0

package/src/component/README.md

@@ -2,9 +2,11 @@
 
 This directory is the isolated Convex component backend.
 
-- `schema.ts`: three tables and query-driven indexes.
+- `schema.ts`: four tables and query-driven indexes.
 - `entries.ts`: entry CRUD, full-text search, duplicate suggestions, entry voting, indexed pagination.
 - `comments.ts`: direct-child pagination, recursive write validation, soft deletion, comment likes.
+- `migrations.ts`: bounded, idempotent legacy-entry backfills.
+- `crons.ts`: immediate upgrade migration and temporary 30-day self-healing schedule.
 - `model.ts`: reusable validators and public model types.
 - `helpers.ts`: normalization, validation, and serializers.
 - `convex.config.ts`: packaged component definition.

package/src/component/_generated/api.ts

@@ -8,10 +8,14 @@
  * @module
  */
 
+import type * as admin from "../admin.js";
 import type * as comments from "../comments.js";
+import type * as crons from "../crons.js";
 import type * as entries from "../entries.js";
 import type * as helpers from "../helpers.js";
+import type * as migrations from "../migrations.js";
 import type * as model from "../model.js";
+import type * as roadmap from "../roadmap.js";
 import type * as types from "../types.js";
 
 import type {
@@ -22,10 +26,14 @@ import type {
 import { anyApi, componentsGeneric } from "convex/server";
 
 const fullApi: ApiFromModules<{
+  admin: typeof admin;
   comments: typeof comments;
+  crons: typeof crons;
   entries: typeof entries;
   helpers: typeof helpers;
+  migrations: typeof migrations;
   model: typeof model;
+  roadmap: typeof roadmap;
   types: typeof types;
 }> = anyApi as any;
 

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;
@@ -190,6 +362,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
             | "in_progress"
             | "completed"
             | "closed";
+          statusFilter?: "open" | "closed";
           viewerActorId?: string;
         },
         {
@@ -237,6 +410,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
             | "in_progress"
             | "completed"
             | "closed";
+          statusFilter?: "open" | "closed";
           viewerActorId?: string;
         },
         Array<{
@@ -264,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"
@@ -352,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;
@@ -364,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,7 +14,9 @@ import {
 } from "./helpers.js";
 import {
   actorValidator,
+  actorIsAdmin,
   commentSortValidator,
+  entryStatusFilterForStatus,
   publicCommentValidator,
 } from "./model.js";
 import schema from "./schema.js";
@@ -121,6 +123,7 @@ export const create = mutation({
 
     await ctx.db.patch("entries", args.entryId, {
       commentCount: entry.commentCount + 1,
+      statusFilter: entryStatusFilterForStatus(entry.status),
     });
 
     if (args.parentCommentId !== undefined) {
@@ -154,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.");
 
@@ -185,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.");