@fatagnus/convex-feedback 0.2.6 → 0.2.7

package/src/convex/_generated/dataModel.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/src/convex/_generated/server.ts

@@ -0,0 +1,161 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/convex/agents/bugReportAgent.ts

@@ -16,7 +16,7 @@ import { v } from "convex/values";
 import { Agent, createThread } from "@convex-dev/agent";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { components, internal } from "../_generated/api";
-import { internalAction, internalQuery } from "../_generated/server";
+import { action, internalAction, internalQuery } from "../_generated/server";
 import type { BugSeverity, Effort } from "../schema";
 
 // Helper to create OpenRouter provider dynamically
@@ -122,14 +122,18 @@ export const getBugReportForAnalysis = internalQuery({
 export const processBugReport = internalAction({
   args: {
     bugReportId: v.id("bugReports"),
+    // Optional API keys - passed from parent app since components don't inherit env vars
+    openRouterApiKey: v.optional(v.string()),
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
   },
   returns: v.object({
     success: v.boolean(),
     error: v.optional(v.string()),
   }),
   handler: async (ctx, args): Promise<{ success: boolean; error?: string }> => {
-    // Check if OpenRouter API key is configured
-    const apiKey = process.env.OPENROUTER_API_KEY;
+    // Check if OpenRouter API key is configured - prefer args (from parent app), fallback to env
+    const apiKey = args.openRouterApiKey || process.env.OPENROUTER_API_KEY;
     if (!apiKey) {
       console.log("OPENROUTER_API_KEY not configured, skipping AI analysis");
       // Still try to send notifications without AI analysis
@@ -137,6 +141,8 @@ export const processBugReport = internalAction({
         await ctx.runAction(internal.emails.bugReportEmails.sendBugReportNotifications, {
           reportId: args.bugReportId,
           analysis: null,
+          resendApiKey: args.resendApiKey,
+          resendFromEmail: args.resendFromEmail,
         });
       } catch {
         console.log("Email notifications not configured");
@@ -262,6 +268,8 @@ Provide your analysis in the JSON format specified.`;
           suggestedFix: analysis.suggestedFix,
           estimatedEffort: analysis.estimatedEffort,
         },
+        resendApiKey: args.resendApiKey,
+        resendFromEmail: args.resendFromEmail,
       });
 
       // Mark notifications as sent
@@ -275,3 +283,29 @@ Provide your analysis in the JSON format specified.`;
     return { success: true };
   },
 });
+
+/**
+ * Public wrapper for processBugReport that can be called from parent app.
+ * Accepts optional API keys since Convex components don't inherit parent env vars.
+ */
+export const processBugReportPublic = action({
+  args: {
+    bugReportId: v.id("bugReports"),
+    openRouterApiKey: v.optional(v.string()),
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args): Promise<{ success: boolean; error?: string }> => {
+    // Delegate to the internal action
+    return await ctx.runAction(internal.agents.bugReportAgent.processBugReport, {
+      bugReportId: args.bugReportId,
+      openRouterApiKey: args.openRouterApiKey,
+      resendApiKey: args.resendApiKey,
+      resendFromEmail: args.resendFromEmail,
+    });
+  },
+});

package/src/convex/agents/feedbackAgent.ts

@@ -15,7 +15,7 @@ import { v } from "convex/values";
 import { Agent, createThread } from "@convex-dev/agent";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { components, internal } from "../_generated/api";
-import { internalAction, internalQuery } from "../_generated/server";
+import { action, internalAction, internalQuery } from "../_generated/server";
 import type { FeedbackPriority, Effort } from "../schema";
 
 // Helper to create OpenRouter provider dynamically
@@ -118,14 +118,18 @@ export const getFeedbackForAnalysis = internalQuery({
 export const processFeedback = internalAction({
   args: {
     feedbackId: v.id("feedback"),
+    // Optional API keys - passed from parent app since components don't inherit env vars
+    openRouterApiKey: v.optional(v.string()),
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
   },
   returns: v.object({
     success: v.boolean(),
     error: v.optional(v.string()),
   }),
   handler: async (ctx, args): Promise<{ success: boolean; error?: string }> => {
-    // Check if OpenRouter API key is configured
-    const apiKey = process.env.OPENROUTER_API_KEY;
+    // Check if OpenRouter API key is configured - prefer args (from parent app), fallback to env
+    const apiKey = args.openRouterApiKey || process.env.OPENROUTER_API_KEY;
     if (!apiKey) {
       console.log("OPENROUTER_API_KEY not configured, skipping AI analysis");
       // Still try to send notifications without AI analysis
@@ -133,6 +137,8 @@ export const processFeedback = internalAction({
         await ctx.runAction(internal.emails.feedbackEmails.sendFeedbackNotifications, {
           feedbackId: args.feedbackId,
           analysis: null,
+          resendApiKey: args.resendApiKey,
+          resendFromEmail: args.resendFromEmail,
         });
       } catch {
         console.log("Email notifications not configured");
@@ -249,6 +255,8 @@ Provide your analysis in the JSON format specified.`;
           estimatedEffort: analysis.estimatedEffort,
           suggestedPriority: analysis.suggestedPriority,
         },
+        resendApiKey: args.resendApiKey,
+        resendFromEmail: args.resendFromEmail,
       });
 
       // Mark notifications as sent
@@ -262,3 +270,29 @@ Provide your analysis in the JSON format specified.`;
     return { success: true };
   },
 });
+
+/**
+ * Public wrapper for processFeedback that can be called from parent app.
+ * Accepts optional API keys since Convex components don't inherit parent env vars.
+ */
+export const processFeedbackPublic = action({
+  args: {
+    feedbackId: v.id("feedback"),
+    openRouterApiKey: v.optional(v.string()),
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
+  },
+  returns: v.object({
+    success: v.boolean(),
+    error: v.optional(v.string()),
+  }),
+  handler: async (ctx, args): Promise<{ success: boolean; error?: string }> => {
+    // Delegate to the internal action
+    return await ctx.runAction(internal.agents.feedbackAgent.processFeedback, {
+      feedbackId: args.feedbackId,
+      openRouterApiKey: args.openRouterApiKey,
+      resendApiKey: args.resendApiKey,
+      resendFromEmail: args.resendFromEmail,
+    });
+  },
+});

package/src/convex/agents/index.ts

@@ -1,13 +1,20 @@
 /**
- * Feedback Interview Agent exports
+ * Agent exports for the feedback component.
+ *
+ * This file exports public actions that can be called from the parent app.
  */
+
+// Re-export all interview agent functions (public actions and queries)
 export {
-  bugInterviewAgent,
-  feedbackInterviewAgent,
   startBugInterview,
   startFeedbackInterview,
   continueInterview,
   getSessionByThread,
-  createSession,
-  updateSession,
 } from "./feedbackInterviewAgent";
+
+// Export public processing actions (for parent app to call with API keys)
+export { processBugReportPublic } from "./bugReportAgent";
+export { processFeedbackPublic } from "./feedbackAgent";
+
+// Note: createSession and updateSession are internalMutation and cannot be re-exported here.
+// They are accessed via internal.agents.feedbackInterviewAgent.* within the component.

package/src/convex/bugReports.ts

@@ -66,6 +66,13 @@ export const create = mutation({
     viewportWidth: v.number(),
     viewportHeight: v.number(),
     networkState: v.string(),
+    // When true, skip auto-scheduling of AI analysis/email notifications
+    // Use this when the parent app will handle processing with its own API keys
+    skipAutoProcess: v.optional(v.boolean()),
+    // Optional API keys - pass from parent app since components don't inherit env vars
+    openRouterApiKey: v.optional(v.string()),
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
   },
   returns: v.id("bugReports"),
   handler: async (ctx, args) => {
@@ -93,14 +100,21 @@ export const create = mutation({
     });
 
     // Schedule AI analysis and email notifications (runs immediately)
-    // This uses a try-catch to gracefully handle if agents aren't configured
-    try {
-      await ctx.scheduler.runAfter(0, internal.agents.bugReportAgent.processBugReport, {
-        bugReportId: reportId,
-      });
-    } catch {
-      // AI agent not available, continue without analysis
-      console.log("AI agent not configured, skipping analysis");
+    // Skip if parent app will handle processing with its own API keys
+    if (!args.skipAutoProcess) {
+      // This uses a try-catch to gracefully handle if agents aren't configured
+      try {
+        await ctx.scheduler.runAfter(0, internal.agents.bugReportAgent.processBugReport, {
+          bugReportId: reportId,
+          // Forward API keys from parent app (components don't inherit env vars)
+          openRouterApiKey: args.openRouterApiKey,
+          resendApiKey: args.resendApiKey,
+          resendFromEmail: args.resendFromEmail,
+        });
+      } catch {
+        // AI agent not available, continue without analysis
+        console.log("AI agent not configured, skipping analysis");
+      }
     }
 
     return reportId;

package/src/convex/emails/bugReportEmails.ts

@@ -347,6 +347,9 @@ export const sendBugReportNotifications = internalAction({
       }),
       v.null()
     ),
+    // Optional API keys - passed from parent app since components don't inherit env vars
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
   },
   returns: v.object({
     success: v.boolean(),
@@ -363,8 +366,8 @@ export const sendBugReportNotifications = internalAction({
     teamEmailsSent: number;
     error?: string;
   }> => {
-    // Check for Resend API key
-    const resendApiKey = process.env.RESEND_API_KEY;
+    // Check for Resend API key - prefer args (from parent app), fallback to env
+    const resendApiKey = args.resendApiKey || process.env.RESEND_API_KEY;
     if (!resendApiKey) {
       console.warn("RESEND_API_KEY not configured. Skipping email notifications.");
       return {
@@ -376,7 +379,7 @@ export const sendBugReportNotifications = internalAction({
     }
 
     const resend = new Resend(resendApiKey);
-    const fromEmail = process.env.RESEND_FROM_EMAIL || "bugs@resend.dev";
+    const fromEmail = args.resendFromEmail || process.env.RESEND_FROM_EMAIL || "bugs@resend.dev";
 
     // Get bug report data
     const report = await ctx.runQuery(

package/src/convex/emails/feedbackEmails.ts

@@ -328,6 +328,9 @@ export const sendFeedbackNotifications = internalAction({
       }),
       v.null()
     ),
+    // Optional API keys - passed from parent app since components don't inherit env vars
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
   },
   returns: v.object({
     success: v.boolean(),
@@ -344,8 +347,8 @@ export const sendFeedbackNotifications = internalAction({
     teamEmailsSent: number;
     error?: string;
   }> => {
-    // Check for Resend API key
-    const resendApiKey = process.env.RESEND_API_KEY;
+    // Check for Resend API key - prefer args (from parent app), fallback to env
+    const resendApiKey = args.resendApiKey || process.env.RESEND_API_KEY;
     if (!resendApiKey) {
       console.warn("RESEND_API_KEY not configured. Skipping email notifications.");
       return {
@@ -357,7 +360,7 @@ export const sendFeedbackNotifications = internalAction({
     }
 
     const resend = new Resend(resendApiKey);
-    const fromEmail = process.env.RESEND_FROM_EMAIL || "feedback@resend.dev";
+    const fromEmail = args.resendFromEmail || process.env.RESEND_FROM_EMAIL || "feedback@resend.dev";
 
     // Get feedback data
     const feedback = await ctx.runQuery(internal.emails.feedbackEmails.getFeedbackForEmail, {

package/src/convex/feedback.ts

@@ -68,6 +68,13 @@ export const create = mutation({
     viewportWidth: v.number(),
     viewportHeight: v.number(),
     networkState: v.string(),
+    // When true, skip auto-scheduling of AI analysis/email notifications
+    // Use this when the parent app will handle processing with its own API keys
+    skipAutoProcess: v.optional(v.boolean()),
+    // Optional API keys - pass from parent app since components don't inherit env vars
+    openRouterApiKey: v.optional(v.string()),
+    resendApiKey: v.optional(v.string()),
+    resendFromEmail: v.optional(v.string()),
   },
   returns: v.id("feedback"),
   handler: async (ctx, args) => {
@@ -96,13 +103,20 @@ export const create = mutation({
     });
 
     // 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");
+    // Skip if parent app will handle processing with its own API keys
+    if (!args.skipAutoProcess) {
+      try {
+        await ctx.scheduler.runAfter(0, internal.agents.feedbackAgent.processFeedback, {
+          feedbackId,
+          // Forward API keys from parent app (components don't inherit env vars)
+          openRouterApiKey: args.openRouterApiKey,
+          resendApiKey: args.resendApiKey,
+          resendFromEmail: args.resendFromEmail,
+        });
+      } catch {
+        // AI agent not available, continue without analysis
+        console.log("AI agent not configured, skipping analysis");
+      }
     }
 
     return feedbackId;

package/src/index.ts

@@ -22,7 +22,23 @@
  * export default app;
  * ```
  *
- * 2. Set required environment variables in your Convex dashboard:
+ * 2. Pass API keys when creating bug reports/feedback:
+ *
+ * **Important:** Convex components don't inherit environment variables from the
+ * parent app. You must pass the API keys when calling the component's create
+ * mutations:
+ *
+ * ```typescript
+ * // In your parent app wrapper function:
+ * await ctx.runMutation(components.feedback.bugReports.create, {
+ *   ...args,
+ *   openRouterApiKey: process.env.OPENROUTER_API_KEY,
+ *   resendApiKey: process.env.RESEND_API_KEY,
+ *   resendFromEmail: process.env.RESEND_FROM_EMAIL,
+ * });
+ * ```
+ *
+ * The following environment variables should be set in your Convex dashboard:
  * - `OPENROUTER_API_KEY` - For AI analysis (optional)
  * - `RESEND_API_KEY` - For email notifications (optional)
  * - `RESEND_FROM_EMAIL` - From address for emails (optional)