@fatagnus/convex-feedback 0.2.7 → 0.2.8

package/src/convex/apiKeys.ts

@@ -0,0 +1,223 @@
+import { v } from "convex/values";
+import { mutation, query, internalQuery } from "./_generated/server";
+
+/**
+ * Generate a secure random API key
+ * Format: fb_<32 random hex chars> = 35 chars total
+ */
+function generateApiKey(): string {
+  const randomBytes = new Uint8Array(16);
+  crypto.getRandomValues(randomBytes);
+  const hex = Array.from(randomBytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+  return `fb_${hex}`;
+}
+
+/**
+ * Hash an API key using SHA-256
+ */
+async function hashApiKey(key: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(key);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+/**
+ * Create a new API key.
+ * Returns the full key - this is the only time it will be visible!
+ */
+export const create = mutation({
+  args: {
+    name: v.string(),
+    expiresAt: v.optional(v.number()),
+  },
+  returns: v.object({
+    key: v.string(),
+    keyPrefix: v.string(),
+    name: v.string(),
+    expiresAt: v.union(v.number(), v.null()),
+    createdAt: v.number(),
+  }),
+  handler: async (ctx, args) => {
+    const key = generateApiKey();
+    const keyHash = await hashApiKey(key);
+    const keyPrefix = key.slice(0, 11); // "fb_" + first 8 chars
+    const now = Date.now();
+
+    await ctx.db.insert("apiKeys", {
+      keyHash,
+      keyPrefix,
+      name: args.name,
+      expiresAt: args.expiresAt,
+      isRevoked: false,
+      createdAt: now,
+    });
+
+    return {
+      key, // Full key - only returned on creation!
+      keyPrefix,
+      name: args.name,
+      expiresAt: args.expiresAt ?? null,
+      createdAt: now,
+    };
+  },
+});
+
+/**
+ * List all API keys (without the actual key values).
+ */
+export const list = query({
+  args: {},
+  returns: v.array(
+    v.object({
+      _id: v.id("apiKeys"),
+      keyPrefix: v.string(),
+      name: v.string(),
+      expiresAt: v.union(v.number(), v.null()),
+      isRevoked: v.boolean(),
+      revokedAt: v.union(v.number(), v.null()),
+      createdAt: v.number(),
+      isExpired: v.boolean(),
+    })
+  ),
+  handler: async (ctx) => {
+    const keys = await ctx.db.query("apiKeys").collect();
+    const now = Date.now();
+
+    return keys.map((k) => ({
+      _id: k._id,
+      keyPrefix: k.keyPrefix,
+      name: k.name,
+      expiresAt: k.expiresAt ?? null,
+      isRevoked: k.isRevoked,
+      revokedAt: k.revokedAt ?? null,
+      createdAt: k.createdAt,
+      isExpired: k.expiresAt !== undefined && k.expiresAt < now,
+    }));
+  },
+});
+
+/**
+ * Revoke an API key by its prefix.
+ */
+export const revoke = mutation({
+  args: {
+    keyPrefix: v.string(),
+  },
+  returns: v.boolean(),
+  handler: async (ctx, args) => {
+    const key = await ctx.db
+      .query("apiKeys")
+      .withIndex("by_key_prefix", (q) => q.eq("keyPrefix", args.keyPrefix))
+      .unique();
+
+    if (!key) {
+      return false;
+    }
+
+    await ctx.db.patch(key._id, {
+      isRevoked: true,
+      revokedAt: Date.now(),
+    });
+
+    return true;
+  },
+});
+
+/**
+ * Rotate an API key - revokes the old key and creates a new one.
+ * Returns the new key (only time it will be visible!).
+ */
+export const rotate = mutation({
+  args: {
+    keyPrefix: v.string(),
+    name: v.optional(v.string()),
+    expiresAt: v.optional(v.number()),
+  },
+  returns: v.union(
+    v.object({
+      key: v.string(),
+      keyPrefix: v.string(),
+      name: v.string(),
+      expiresAt: v.union(v.number(), v.null()),
+      createdAt: v.number(),
+    }),
+    v.null()
+  ),
+  handler: async (ctx, args) => {
+    // Find and revoke the old key
+    const oldKey = await ctx.db
+      .query("apiKeys")
+      .withIndex("by_key_prefix", (q) => q.eq("keyPrefix", args.keyPrefix))
+      .unique();
+
+    if (!oldKey) {
+      return null;
+    }
+
+    // Revoke old key
+    await ctx.db.patch(oldKey._id, {
+      isRevoked: true,
+      revokedAt: Date.now(),
+    });
+
+    // Create new key
+    const newKey = generateApiKey();
+    const keyHash = await hashApiKey(newKey);
+    const keyPrefix = newKey.slice(0, 11);
+    const now = Date.now();
+    const name = args.name ?? oldKey.name;
+
+    await ctx.db.insert("apiKeys", {
+      keyHash,
+      keyPrefix,
+      name,
+      expiresAt: args.expiresAt,
+      isRevoked: false,
+      createdAt: now,
+    });
+
+    return {
+      key: newKey,
+      keyPrefix,
+      name,
+      expiresAt: args.expiresAt ?? null,
+      createdAt: now,
+    };
+  },
+});
+
+/**
+ * Validate an API key (internal use for HTTP endpoint).
+ * Returns true if valid and not expired/revoked.
+ */
+export const validateKey = internalQuery({
+  args: {
+    key: v.string(),
+  },
+  returns: v.boolean(),
+  handler: async (ctx, args) => {
+    const keyHash = await hashApiKey(args.key);
+    const apiKey = await ctx.db
+      .query("apiKeys")
+      .withIndex("by_key_hash", (q) => q.eq("keyHash", keyHash))
+      .unique();
+
+    if (!apiKey) {
+      return false;
+    }
+
+    if (apiKey.isRevoked) {
+      return false;
+    }
+
+    if (apiKey.expiresAt !== undefined && apiKey.expiresAt < Date.now()) {
+      return false;
+    }
+
+    return true;
+  },
+});

package/src/convex/bugReports.ts

@@ -1,5 +1,5 @@
 import { v } from "convex/values";
-import { mutation, query, internalMutation } from "./_generated/server";
+import { mutation, query, internalMutation, internalQuery } from "./_generated/server";
 import { internal } from "./_generated/api";
 import {
   bugSeverityValidator,
@@ -41,6 +41,7 @@ const bugReportReturnValidator = v.object({
   aiAnalyzedAt: v.optional(v.number()),
   aiThreadId: v.optional(v.string()),
   notificationsSentAt: v.optional(v.number()),
+  ticketNumber: v.optional(v.string()),
 });
 
 /**
@@ -78,6 +79,27 @@ export const create = mutation({
   handler: async (ctx, args) => {
     const now = Date.now();
 
+    // Generate ticket number
+    const year = new Date().getFullYear();
+    const counter = await ctx.db
+      .query("ticketCounters")
+      .withIndex("by_type_year", (q) => q.eq("type", "bug").eq("year", year))
+      .unique();
+
+    let nextNumber: number;
+    if (counter) {
+      nextNumber = counter.nextNumber;
+      await ctx.db.patch(counter._id, { nextNumber: nextNumber + 1 });
+    } else {
+      nextNumber = 1;
+      await ctx.db.insert("ticketCounters", {
+        type: "bug",
+        year,
+        nextNumber: 2,
+      });
+    }
+    const ticketNumber = `BUG-${year}-${nextNumber.toString().padStart(4, "0")}`;
+
     const reportId = await ctx.db.insert("bugReports", {
       title: args.title,
       description: args.description,
@@ -95,6 +117,7 @@ export const create = mutation({
       viewportWidth: args.viewportWidth,
       viewportHeight: args.viewportHeight,
       networkState: args.networkState,
+      ticketNumber,
       createdAt: now,
       updatedAt: now,
     });
@@ -346,6 +369,108 @@ export const updateWithAnalysis = internalMutation({
   },
 });
 
+/**
+ * Internal query to list bug reports (for HTTP API).
+ */
+export const listInternal = internalQuery({
+  args: {
+    status: v.optional(bugStatusValidator),
+    severity: v.optional(bugSeverityValidator),
+    includeArchived: v.optional(v.boolean()),
+    limit: v.optional(v.number()),
+  },
+  returns: v.array(bugReportReturnValidator),
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 50;
+    const includeArchived = args.includeArchived ?? false;
+
+    let reports;
+    if (args.status) {
+      const status = args.status;
+      reports = await ctx.db
+        .query("bugReports")
+        .withIndex("by_status", (q) => q.eq("status", status))
+        .order("desc")
+        .take(limit * 2);
+    } else if (args.severity) {
+      const severity = args.severity;
+      reports = await ctx.db
+        .query("bugReports")
+        .withIndex("by_severity", (q) => q.eq("severity", severity))
+        .order("desc")
+        .take(limit * 2);
+    } else {
+      reports = await ctx.db
+        .query("bugReports")
+        .withIndex("by_created")
+        .order("desc")
+        .take(limit * 2);
+    }
+
+    if (!includeArchived) {
+      reports = reports.filter((r) => !r.isArchived);
+    }
+
+    return reports.slice(0, limit);
+  },
+});
+
+/**
+ * Internal mutation to update bug report status by ticket number (for HTTP API).
+ */
+export const updateStatusByTicketNumber = internalMutation({
+  args: {
+    ticketNumber: v.string(),
+    status: bugStatusValidator,
+  },
+  returns: v.union(v.object({ success: v.boolean(), ticketNumber: v.string() }), v.null()),
+  handler: async (ctx, args) => {
+    const report = await ctx.db
+      .query("bugReports")
+      .withIndex("by_ticket_number", (q) => q.eq("ticketNumber", args.ticketNumber))
+      .unique();
+
+    if (!report) {
+      return null;
+    }
+
+    await ctx.db.patch(report._id, {
+      status: args.status,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true, ticketNumber: args.ticketNumber };
+  },
+});
+
+/**
+ * Internal mutation to archive/unarchive bug report by ticket number (for HTTP API).
+ */
+export const setArchivedByTicketNumber = internalMutation({
+  args: {
+    ticketNumber: v.string(),
+    isArchived: v.boolean(),
+  },
+  returns: v.union(v.object({ success: v.boolean(), ticketNumber: v.string(), isArchived: v.boolean() }), v.null()),
+  handler: async (ctx, args) => {
+    const report = await ctx.db
+      .query("bugReports")
+      .withIndex("by_ticket_number", (q) => q.eq("ticketNumber", args.ticketNumber))
+      .unique();
+
+    if (!report) {
+      return null;
+    }
+
+    await ctx.db.patch(report._id, {
+      isArchived: args.isArchived,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true, ticketNumber: args.ticketNumber, isArchived: args.isArchived };
+  },
+});
+
 /**
  * Internal mutation to mark notifications as sent
  */

package/src/convex/feedback.ts

@@ -1,5 +1,5 @@
 import { v } from "convex/values";
-import { mutation, query, internalMutation } from "./_generated/server";
+import { mutation, query, internalMutation, internalQuery } from "./_generated/server";
 import { internal } from "./_generated/api";
 import {
   feedbackTypeValidator,
@@ -42,6 +42,7 @@ const feedbackReturnValidator = v.object({
   aiAnalyzedAt: v.optional(v.number()),
   aiThreadId: v.optional(v.string()),
   notificationsSentAt: v.optional(v.number()),
+  ticketNumber: v.optional(v.string()),
 });
 
 /**
@@ -80,6 +81,27 @@ export const create = mutation({
   handler: async (ctx, args) => {
     const now = Date.now();
 
+    // Generate ticket number
+    const year = new Date().getFullYear();
+    const counter = await ctx.db
+      .query("ticketCounters")
+      .withIndex("by_type_year", (q) => q.eq("type", "feedback").eq("year", year))
+      .unique();
+
+    let nextNumber: number;
+    if (counter) {
+      nextNumber = counter.nextNumber;
+      await ctx.db.patch(counter._id, { nextNumber: nextNumber + 1 });
+    } else {
+      nextNumber = 1;
+      await ctx.db.insert("ticketCounters", {
+        type: "feedback",
+        year,
+        nextNumber: 2,
+      });
+    }
+    const ticketNumber = `FB-${year}-${nextNumber.toString().padStart(4, "0")}`;
+
     const feedbackId = await ctx.db.insert("feedback", {
       type: args.type,
       title: args.title,
@@ -98,6 +120,7 @@ export const create = mutation({
       viewportWidth: args.viewportWidth,
       viewportHeight: args.viewportHeight,
       networkState: args.networkState,
+      ticketNumber,
       createdAt: now,
       updatedAt: now,
     });
@@ -368,3 +391,113 @@ export const markNotificationsSent = internalMutation({
     return null;
   },
 });
+
+/**
+ * Internal query to list feedback (for HTTP API).
+ */
+export const listInternal = internalQuery({
+  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);
+    }
+
+    if (!includeArchived) {
+      results = results.filter((r) => !r.isArchived);
+    }
+
+    return results.slice(0, limit);
+  },
+});
+
+/**
+ * Internal mutation to archive/unarchive feedback by ticket number (for HTTP API).
+ */
+export const setArchivedByTicketNumber = internalMutation({
+  args: {
+    ticketNumber: v.string(),
+    isArchived: v.boolean(),
+  },
+  returns: v.union(v.object({ success: v.boolean(), ticketNumber: v.string(), isArchived: v.boolean() }), v.null()),
+  handler: async (ctx, args) => {
+    const feedback = await ctx.db
+      .query("feedback")
+      .withIndex("by_ticket_number", (q) => q.eq("ticketNumber", args.ticketNumber))
+      .unique();
+
+    if (!feedback) {
+      return null;
+    }
+
+    await ctx.db.patch(feedback._id, {
+      isArchived: args.isArchived,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true, ticketNumber: args.ticketNumber, isArchived: args.isArchived };
+  },
+});
+
+/**
+ * Internal mutation to update feedback status by ticket number (for HTTP API).
+ */
+export const updateStatusByTicketNumber = internalMutation({
+  args: {
+    ticketNumber: v.string(),
+    status: feedbackStatusValidator,
+  },
+  returns: v.union(v.object({ success: v.boolean(), ticketNumber: v.string() }), v.null()),
+  handler: async (ctx, args) => {
+    const feedback = await ctx.db
+      .query("feedback")
+      .withIndex("by_ticket_number", (q) => q.eq("ticketNumber", args.ticketNumber))
+      .unique();
+
+    if (!feedback) {
+      return null;
+    }
+
+    await ctx.db.patch(feedback._id, {
+      status: args.status,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true, ticketNumber: args.ticketNumber };
+  },
+});

package/src/convex/http.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Unit tests for HTTP API - Ticket Number Format Validation
+ * 
+ * Note: Testing Convex component packages with convex-test requires special setup
+ * due to the @convex-dev/agent dependency. These tests verify ticket number formats
+ * used by the HTTP API endpoints.
+ * 
+ * For full integration testing of queries/mutations, run the component in a real
+ * Convex deployment or see the main project's test patterns.
+ * 
+ * Prompt generation tests are in prompts.test.ts
+ * API key format tests are in apiKeys.test.ts
+ */
+import { describe, it, expect } from "vitest";
+
+describe("HTTP API - Ticket Number Format", () => {
+  describe("Bug Report Ticket Numbers", () => {
+    it("follows BUG-YYYY-NNNN format", () => {
+      const validPattern = /^BUG-\d{4}-\d{4}$/;
+      
+      expect("BUG-2025-0001").toMatch(validPattern);
+      expect("BUG-2025-0123").toMatch(validPattern);
+      expect("BUG-2024-9999").toMatch(validPattern);
+    });
+
+    it("pads sequence number to 4 digits", () => {
+      const formatTicketNumber = (year: number, seq: number) => 
+        `BUG-${year}-${seq.toString().padStart(4, "0")}`;
+      
+      expect(formatTicketNumber(2025, 1)).toBe("BUG-2025-0001");
+      expect(formatTicketNumber(2025, 42)).toBe("BUG-2025-0042");
+      expect(formatTicketNumber(2025, 999)).toBe("BUG-2025-0999");
+      expect(formatTicketNumber(2025, 1234)).toBe("BUG-2025-1234");
+    });
+  });
+
+  describe("Feedback Ticket Numbers", () => {
+    it("follows FB-YYYY-NNNN format", () => {
+      const validPattern = /^FB-\d{4}-\d{4}$/;
+      
+      expect("FB-2025-0001").toMatch(validPattern);
+      expect("FB-2025-0123").toMatch(validPattern);
+      expect("FB-2024-9999").toMatch(validPattern);
+    });
+
+    it("pads sequence number to 4 digits", () => {
+      const formatTicketNumber = (year: number, seq: number) => 
+        `FB-${year}-${seq.toString().padStart(4, "0")}`;
+      
+      expect(formatTicketNumber(2025, 1)).toBe("FB-2025-0001");
+      expect(formatTicketNumber(2025, 42)).toBe("FB-2025-0042");
+      expect(formatTicketNumber(2025, 999)).toBe("FB-2025-0999");
+      expect(formatTicketNumber(2025, 1234)).toBe("FB-2025-1234");
+    });
+  });
+
+  describe("Ticket Number Parsing", () => {
+    it("can identify bug tickets by prefix", () => {
+      const ticketNumber = "BUG-2025-0001";
+      expect(ticketNumber.startsWith("BUG-")).toBe(true);
+      expect(ticketNumber.startsWith("FB-")).toBe(false);
+    });
+
+    it("can identify feedback tickets by prefix", () => {
+      const ticketNumber = "FB-2025-0001";
+      expect(ticketNumber.startsWith("FB-")).toBe(true);
+      expect(ticketNumber.startsWith("BUG-")).toBe(false);
+    });
+
+    it("normalizes ticket numbers to uppercase", () => {
+      const lowercase = "bug-2025-0001";
+      const normalized = lowercase.toUpperCase();
+      expect(normalized).toBe("BUG-2025-0001");
+    });
+  });
+});