@fatagnus/convex-feedback 0.1.0

package/src/convex/feedback.ts

@@ -0,0 +1,356 @@
+import { v } from "convex/values";
+import { mutation, query, internalMutation } from "./_generated/server";
+import { internal } from "./_generated/api";
+import {
+  feedbackTypeValidator,
+  feedbackPriorityValidator,
+  feedbackStatusValidator,
+  reporterTypeValidator,
+  effortValidator,
+} from "./schema";
+
+// Return type for feedback records
+const feedbackReturnValidator = v.object({
+  _id: v.id("feedback"),
+  _creationTime: v.number(),
+  type: feedbackTypeValidator,
+  title: v.string(),
+  description: v.string(),
+  priority: feedbackPriorityValidator,
+  status: feedbackStatusValidator,
+  isArchived: v.optional(v.boolean()),
+  reporterType: reporterTypeValidator,
+  reporterId: v.string(),
+  reporterEmail: v.string(),
+  reporterName: v.string(),
+  url: v.string(),
+  route: v.optional(v.string()),
+  browserInfo: v.string(),
+  consoleErrors: v.optional(v.string()),
+  screenshotStorageId: v.optional(v.id("_storage")),
+  viewportWidth: v.number(),
+  viewportHeight: v.number(),
+  networkState: v.string(),
+  createdAt: v.number(),
+  updatedAt: v.number(),
+  // AI Analysis fields
+  aiSummary: v.optional(v.string()),
+  aiImpactAnalysis: v.optional(v.string()),
+  aiActionItems: v.optional(v.array(v.string())),
+  aiEstimatedEffort: v.optional(effortValidator),
+  aiSuggestedPriority: v.optional(feedbackPriorityValidator),
+  aiAnalyzedAt: v.optional(v.number()),
+  aiThreadId: v.optional(v.string()),
+  notificationsSentAt: v.optional(v.number()),
+});
+
+/**
+ * Create new feedback.
+ * This mutation is intentionally public (no auth required) because:
+ * 1. We want to capture feedback even when auth might be broken
+ * 2. The reporter info is passed explicitly from the client
+ */
+export const create = mutation({
+  args: {
+    type: feedbackTypeValidator,
+    title: v.string(),
+    description: v.string(),
+    priority: feedbackPriorityValidator,
+    reporterType: reporterTypeValidator,
+    reporterId: v.string(),
+    reporterEmail: v.string(),
+    reporterName: v.string(),
+    url: v.string(),
+    route: v.optional(v.string()),
+    browserInfo: v.string(),
+    consoleErrors: v.optional(v.string()),
+    screenshotStorageId: v.optional(v.id("_storage")),
+    viewportWidth: v.number(),
+    viewportHeight: v.number(),
+    networkState: v.string(),
+  },
+  returns: v.id("feedback"),
+  handler: async (ctx, args) => {
+    const now = Date.now();
+
+    const feedbackId = await ctx.db.insert("feedback", {
+      type: args.type,
+      title: args.title,
+      description: args.description,
+      priority: args.priority,
+      status: "open",
+      reporterType: args.reporterType,
+      reporterId: args.reporterId,
+      reporterEmail: args.reporterEmail,
+      reporterName: args.reporterName,
+      url: args.url,
+      route: args.route,
+      browserInfo: args.browserInfo,
+      consoleErrors: args.consoleErrors,
+      screenshotStorageId: args.screenshotStorageId,
+      viewportWidth: args.viewportWidth,
+      viewportHeight: args.viewportHeight,
+      networkState: args.networkState,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    // Schedule AI analysis and email notifications (runs immediately)
+    try {
+      await ctx.scheduler.runAfter(0, internal.agents.feedbackAgent.processFeedback, {
+        feedbackId,
+      });
+    } catch {
+      // AI agent not available, continue without analysis
+      console.log("AI agent not configured, skipping analysis");
+    }
+
+    return feedbackId;
+  },
+});
+
+/**
+ * List feedback with optional filters.
+ * By default, archived items are excluded unless includeArchived is true.
+ */
+export const list = query({
+  args: {
+    status: v.optional(feedbackStatusValidator),
+    type: v.optional(feedbackTypeValidator),
+    priority: v.optional(feedbackPriorityValidator),
+    includeArchived: v.optional(v.boolean()),
+    limit: v.optional(v.number()),
+  },
+  returns: v.array(feedbackReturnValidator),
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 50;
+    const includeArchived = args.includeArchived ?? false;
+
+    let results;
+    if (args.status) {
+      const status = args.status;
+      results = await ctx.db
+        .query("feedback")
+        .withIndex("by_status", (q) => q.eq("status", status))
+        .order("desc")
+        .take(limit * 2);
+    } else if (args.type) {
+      const type = args.type;
+      results = await ctx.db
+        .query("feedback")
+        .withIndex("by_type", (q) => q.eq("type", type))
+        .order("desc")
+        .take(limit * 2);
+    } else if (args.priority) {
+      const priority = args.priority;
+      results = await ctx.db
+        .query("feedback")
+        .withIndex("by_priority", (q) => q.eq("priority", priority))
+        .order("desc")
+        .take(limit * 2);
+    } else {
+      results = await ctx.db
+        .query("feedback")
+        .withIndex("by_created")
+        .order("desc")
+        .take(limit * 2);
+    }
+
+    // Filter out archived items unless includeArchived is true
+    if (!includeArchived) {
+      results = results.filter((r) => !r.isArchived);
+    }
+
+    return results.slice(0, limit);
+  },
+});
+
+/**
+ * Get a single feedback by ID.
+ */
+export const get = query({
+  args: {
+    feedbackId: v.id("feedback"),
+  },
+  returns: v.union(feedbackReturnValidator, v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.feedbackId);
+  },
+});
+
+/**
+ * Update feedback status.
+ */
+export const updateStatus = mutation({
+  args: {
+    feedbackId: v.id("feedback"),
+    status: feedbackStatusValidator,
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const feedback = await ctx.db.get(args.feedbackId);
+    if (!feedback) {
+      throw new Error("Feedback not found");
+    }
+
+    await ctx.db.patch(args.feedbackId, {
+      status: args.status,
+      updatedAt: Date.now(),
+    });
+
+    return null;
+  },
+});
+
+/**
+ * Generate upload URL for screenshot.
+ */
+export const generateUploadUrl = mutation({
+  args: {},
+  returns: v.string(),
+  handler: async (ctx) => {
+    return await ctx.storage.generateUploadUrl();
+  },
+});
+
+/**
+ * Get screenshot URL from storage ID.
+ */
+export const getScreenshotUrl = query({
+  args: {
+    storageId: v.id("_storage"),
+  },
+  returns: v.union(v.string(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.storage.getUrl(args.storageId);
+  },
+});
+
+/**
+ * Archive feedback.
+ */
+export const archive = mutation({
+  args: {
+    feedbackId: v.id("feedback"),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const feedback = await ctx.db.get(args.feedbackId);
+    if (!feedback) {
+      throw new Error("Feedback not found");
+    }
+
+    await ctx.db.patch(args.feedbackId, {
+      isArchived: true,
+      updatedAt: Date.now(),
+    });
+
+    return null;
+  },
+});
+
+/**
+ * Unarchive feedback.
+ */
+export const unarchive = mutation({
+  args: {
+    feedbackId: v.id("feedback"),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const feedback = await ctx.db.get(args.feedbackId);
+    if (!feedback) {
+      throw new Error("Feedback not found");
+    }
+
+    await ctx.db.patch(args.feedbackId, {
+      isArchived: false,
+      updatedAt: Date.now(),
+    });
+
+    return null;
+  },
+});
+
+/**
+ * Get AI analysis for a specific feedback.
+ */
+export const getAiAnalysis = query({
+  args: {
+    feedbackId: v.id("feedback"),
+  },
+  returns: v.union(
+    v.object({
+      aiSummary: v.union(v.string(), v.null()),
+      aiImpactAnalysis: v.union(v.string(), v.null()),
+      aiActionItems: v.union(v.array(v.string()), v.null()),
+      aiEstimatedEffort: v.union(effortValidator, v.null()),
+      aiSuggestedPriority: v.union(feedbackPriorityValidator, v.null()),
+      aiAnalyzedAt: v.union(v.number(), v.null()),
+      notificationsSentAt: v.union(v.number(), v.null()),
+    }),
+    v.null()
+  ),
+  handler: async (ctx, args) => {
+    const feedback = await ctx.db.get(args.feedbackId);
+    if (!feedback) {
+      return null;
+    }
+
+    return {
+      aiSummary: feedback.aiSummary ?? null,
+      aiImpactAnalysis: feedback.aiImpactAnalysis ?? null,
+      aiActionItems: feedback.aiActionItems ?? null,
+      aiEstimatedEffort: feedback.aiEstimatedEffort ?? null,
+      aiSuggestedPriority: feedback.aiSuggestedPriority ?? null,
+      aiAnalyzedAt: feedback.aiAnalyzedAt ?? null,
+      notificationsSentAt: feedback.notificationsSentAt ?? null,
+    };
+  },
+});
+
+/**
+ * Internal mutation to update feedback with AI analysis results
+ */
+export const updateWithAnalysis = internalMutation({
+  args: {
+    feedbackId: v.id("feedback"),
+    aiSummary: v.string(),
+    aiImpactAnalysis: v.string(),
+    aiActionItems: v.array(v.string()),
+    aiEstimatedEffort: effortValidator,
+    aiSuggestedPriority: feedbackPriorityValidator,
+    aiThreadId: v.string(),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.feedbackId, {
+      aiSummary: args.aiSummary,
+      aiImpactAnalysis: args.aiImpactAnalysis,
+      aiActionItems: args.aiActionItems,
+      aiEstimatedEffort: args.aiEstimatedEffort,
+      aiSuggestedPriority: args.aiSuggestedPriority,
+      aiThreadId: args.aiThreadId,
+      aiAnalyzedAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    return null;
+  },
+});
+
+/**
+ * Internal mutation to mark notifications as sent
+ */
+export const markNotificationsSent = internalMutation({
+  args: {
+    feedbackId: v.id("feedback"),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.feedbackId, {
+      notificationsSentAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    return null;
+  },
+});

package/src/convex/index.ts

@@ -0,0 +1,28 @@
+/**
+ * @convex-dev/feedback - Convex Functions
+ *
+ * Export all Convex functions for use by the component.
+ */
+
+// Re-export all public functions
+export * as bugReports from './bugReports';
+export * as feedback from './feedback';
+export * as supportTeams from './supportTeams';
+
+// Re-export schema types and validators
+export {
+  bugSeverityValidator,
+  bugStatusValidator,
+  feedbackTypeValidator,
+  feedbackPriorityValidator,
+  feedbackStatusValidator,
+  reporterTypeValidator,
+  effortValidator,
+  type BugSeverity,
+  type BugStatus,
+  type FeedbackType,
+  type FeedbackPriority,
+  type FeedbackStatus,
+  type ReporterType,
+  type Effort,
+} from './schema';

package/src/convex/schema.ts

@@ -0,0 +1,207 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+// ===== Validators =====
+
+/**
+ * Bug report severity levels
+ */
+export const bugSeverityValidator = v.union(
+  v.literal("low"),
+  v.literal("medium"),
+  v.literal("high"),
+  v.literal("critical")
+);
+
+export type BugSeverity = "low" | "medium" | "high" | "critical";
+
+/**
+ * Bug report status
+ */
+export const bugStatusValidator = v.union(
+  v.literal("open"),
+  v.literal("in-progress"),
+  v.literal("resolved"),
+  v.literal("closed")
+);
+
+export type BugStatus = "open" | "in-progress" | "resolved" | "closed";
+
+/**
+ * Feedback type
+ */
+export const feedbackTypeValidator = v.union(
+  v.literal("feature_request"),
+  v.literal("change_request"),
+  v.literal("general")
+);
+
+export type FeedbackType = "feature_request" | "change_request" | "general";
+
+/**
+ * Feedback priority
+ */
+export const feedbackPriorityValidator = v.union(
+  v.literal("nice_to_have"),
+  v.literal("important"),
+  v.literal("critical")
+);
+
+export type FeedbackPriority = "nice_to_have" | "important" | "critical";
+
+/**
+ * Feedback status
+ */
+export const feedbackStatusValidator = v.union(
+  v.literal("open"),
+  v.literal("under_review"),
+  v.literal("planned"),
+  v.literal("in_progress"),
+  v.literal("completed"),
+  v.literal("declined")
+);
+
+export type FeedbackStatus = "open" | "under_review" | "planned" | "in_progress" | "completed" | "declined";
+
+/**
+ * Reporter type
+ */
+export const reporterTypeValidator = v.union(
+  v.literal("staff"),
+  v.literal("customer")
+);
+
+export type ReporterType = "staff" | "customer";
+
+/**
+ * Effort estimate
+ */
+export const effortValidator = v.union(
+  v.literal("low"),
+  v.literal("medium"),
+  v.literal("high")
+);
+
+export type Effort = "low" | "medium" | "high";
+
+// ===== Schema =====
+
+export default defineSchema({
+  /**
+   * Bug Reports - in-app bug reports with diagnostics
+   */
+  bugReports: defineTable({
+    // Report content
+    title: v.string(),
+    description: v.string(),
+    severity: bugSeverityValidator,
+    status: bugStatusValidator,
+    // Archive flag
+    isArchived: v.optional(v.boolean()),
+    // Reporter info
+    reporterType: reporterTypeValidator,
+    reporterId: v.string(),
+    reporterEmail: v.string(),
+    reporterName: v.string(),
+    // Page context
+    url: v.string(),
+    route: v.optional(v.string()),
+    // Browser diagnostics
+    browserInfo: v.string(), // JSON stringified browser info
+    consoleErrors: v.optional(v.string()), // JSON stringified array of errors
+    // Screenshot
+    screenshotStorageId: v.optional(v.id("_storage")),
+    // Viewport
+    viewportWidth: v.number(),
+    viewportHeight: v.number(),
+    // Network state
+    networkState: v.string(), // online/offline
+    // AI Analysis fields
+    aiSummary: v.optional(v.string()),
+    aiRootCauseAnalysis: v.optional(v.string()),
+    aiReproductionSteps: v.optional(v.array(v.string())),
+    aiSuggestedFix: v.optional(v.string()),
+    aiEstimatedEffort: v.optional(effortValidator),
+    aiSuggestedSeverity: v.optional(bugSeverityValidator),
+    aiAnalyzedAt: v.optional(v.number()),
+    aiThreadId: v.optional(v.string()),
+    notificationsSentAt: v.optional(v.number()),
+    // Timestamps
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_status", ["status"])
+    .index("by_severity", ["severity"])
+    .index("by_reporter", ["reporterType", "reporterId"])
+    .index("by_created", ["createdAt"])
+    .index("by_archived", ["isArchived"])
+    .index("by_ai_analyzed", ["aiAnalyzedAt"]),
+
+  /**
+   * Feedback - feature requests, change requests, and general feedback
+   */
+  feedback: defineTable({
+    // Feedback type
+    type: feedbackTypeValidator,
+    // Content
+    title: v.string(),
+    description: v.string(),
+    priority: feedbackPriorityValidator,
+    status: feedbackStatusValidator,
+    // Archive flag
+    isArchived: v.optional(v.boolean()),
+    // Reporter info
+    reporterType: reporterTypeValidator,
+    reporterId: v.string(),
+    reporterEmail: v.string(),
+    reporterName: v.string(),
+    // Page context
+    url: v.string(),
+    route: v.optional(v.string()),
+    // Browser diagnostics
+    browserInfo: v.string(),
+    consoleErrors: v.optional(v.string()),
+    // Screenshot
+    screenshotStorageId: v.optional(v.id("_storage")),
+    // Viewport
+    viewportWidth: v.number(),
+    viewportHeight: v.number(),
+    // Network state
+    networkState: v.string(),
+    // AI Analysis fields
+    aiSummary: v.optional(v.string()),
+    aiImpactAnalysis: v.optional(v.string()),
+    aiActionItems: v.optional(v.array(v.string())),
+    aiEstimatedEffort: v.optional(effortValidator),
+    aiSuggestedPriority: v.optional(feedbackPriorityValidator),
+    aiAnalyzedAt: v.optional(v.number()),
+    aiThreadId: v.optional(v.string()),
+    notificationsSentAt: v.optional(v.number()),
+    // Timestamps
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_status", ["status"])
+    .index("by_type", ["type"])
+    .index("by_priority", ["priority"])
+    .index("by_reporter", ["reporterType", "reporterId"])
+    .index("by_created", ["createdAt"])
+    .index("by_archived", ["isArchived"])
+    .index("by_ai_analyzed", ["aiAnalyzedAt"]),
+
+  /**
+   * Support Teams - configure teams for notification routing
+   */
+  supportTeams: defineTable({
+    teamName: v.string(),
+    memberEmails: v.array(v.string()),
+    // Multi-select: which feedback types this team handles
+    feedbackTypes: v.array(feedbackTypeValidator),
+    // Multi-select: which bug report severities this team handles
+    bugReportSeverities: v.array(bugSeverityValidator),
+    isActive: v.boolean(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_active", ["isActive"]),
+});