CodeRabbit Convex Adapter

/**
 * Convex Storage Adapter
 * Real-time database adapter with auth support
 */

import type {
  ReportStorageAdapter,
  ListReportsResponse,
} from '@/registry/default/lib/storage-adapter'
import type {
  StoredReport,
  ReportResult,
} from '@/registry/default/lib/types'

/**
 * Convex client interface - matches the ConvexReactClient API
 */
interface ConvexClient {
  mutation<T>(functionReference: unknown, args: unknown): Promise<T>
  query<T>(functionReference: unknown, args: unknown): Promise<T>
}

/**
 * Convex API structure for CodeRabbit reports
 * Users should pass their api.coderabbit object
 */
interface ConvexCodeRabbitApi {
  coderabbit: {
    createReport: unknown
    updateReportSuccess: unknown
    updateReportFailure: unknown
    getReport: unknown
    listReports: unknown
    deleteReport: unknown
  }
}

/**
 * Convex storage adapter
 * Uses Convex for real-time database with auth support
 *
 * Note: This adapter assumes you have:
 * - ConvexReactClient instance
 * - API functions defined in convex/coderabbit.ts
 */
export class ConvexStorageAdapter implements ReportStorageAdapter {
  constructor(
    private client: ConvexClient,
    private api: ConvexCodeRabbitApi,
  ) {}

  async create(data: Omit<StoredReport, 'id' | 'createdAt'>): Promise<string> {
    return await this.client.mutation(this.api.coderabbit.createReport, data)
  }

  async updateSuccess(
    id: string,
    results: ReportResult[],
    durationMs: number,
  ): Promise<void> {
    await this.client.mutation(this.api.coderabbit.updateReportSuccess, {
      id,
      results,
      durationMs,
    })
  }

  async updateFailure(
    id: string,
    error: string,
    durationMs: number,
  ): Promise<void> {
    await this.client.mutation(this.api.coderabbit.updateReportFailure, {
      id,
      error,
      durationMs,
    })
  }

  async get(id: string): Promise<StoredReport | null> {
    return await this.client.query(this.api.coderabbit.getReport, { id })
  }

  async list(options?: {
    limit?: number
    offset?: number
  }): Promise<ListReportsResponse> {
    return await this.client.query(
      this.api.coderabbit.listReports,
      options ?? {},
    )
  }

  async delete(id: string): Promise<void> {
    await this.client.mutation(this.api.coderabbit.deleteReport, { id })
  }
}

/**
 * CodeRabbit Schema for Convex
 * Generic schema that matches StoredReport interface from types.ts
 * Minimal and framework-agnostic - works with any database
 */

import { defineTable } from 'convex/server'
import { v } from 'convex/values'

/**
 * CodeRabbit reports table schema
 * Use this exact table name: coderabbit_reports
 */
export const coderabbitReportsTable = defineTable({
  fromDate: v.string(),
  toDate: v.string(),
  prompt: v.optional(v.string()),
  promptTemplate: v.optional(v.string()),
  customPrompt: v.optional(v.string()),
  groupBy: v.optional(v.string()),
  subgroupBy: v.optional(v.string()),
  orgId: v.optional(v.string()),
  parameters: v.optional(
    v.array(
      v.object({
        parameter: v.string(),
        operator: v.string(),
        values: v.array(v.string()),
      }),
    ),
  ),
  results: v.array(
    v.object({
      group: v.string(),
      report: v.string(),
    }),
  ),
  status: v.union(
    v.literal('pending'),
    v.literal('completed'),
    v.literal('failed'),
  ),
  error: v.optional(v.string()),
  createdAt: v.number(),
  durationMs: v.optional(v.number()),
})
  .index('by_status', ['status'])
  .index('by_created_at', ['createdAt'])

/**
 * Add to your convex/schema.ts in your application:
 *
 * import { coderabbitReportsTable } from './coderabbit-schema'
 *
 * export default defineSchema({
 *   coderabbit_reports: coderabbitReportsTable,
 *   // ... your other tables
 * })
 *
 * IMPORTANT: Use the exact table name 'coderabbit_reports'
 */