refactor: database scripts and models for improved performance and error handling

Author: devarshishimpi

scripts/fix-max-files.mjs

@@ -30,24 +30,12 @@ const sql = postgres(databaseUrl, { onnotice: () => {} });
 
 async function run() {
   try {
-    const rows = await sql`SELECT repository_id, parsed_json FROM repo_configs`;
-    let count = 0;
-    for (const row of rows) {
-      let parsed = row.parsed_json;
-      if (typeof parsed === 'string') {
-        parsed = JSON.parse(parsed);
-      }
-      if (parsed?.review?.max_files === 15) {
-        parsed.review.max_files = 100;
-        await sql`
-          UPDATE repo_configs 
-          SET parsed_json = ${JSON.stringify(parsed)}::jsonb 
-          WHERE repository_id = ${row.repository_id}
-        `;
-        count++;
-      }
-    }
-    console.log(`Updated ${count} repository configurations from 15 to 100.`);
+    const result = await sql`
+      UPDATE repo_configs
+      SET parsed_json = jsonb_set(parsed_json, '{review,max_files}', '100'::jsonb)
+      WHERE parsed_json#>>'{review,max_files}' = '15'
+    `;
+    console.log(`Updated ${result.count} repository configurations from 15 to 100.`);
   } catch (err) {
     console.error(err);
   } finally {

scripts/migrate.mjs

@@ -309,6 +309,7 @@ async function ensureModelCatalog() {
       FROM llm_providers provider_record
       WHERE mc.provider_id IS NULL
         AND provider_record.name = 'Cloudflare'
+        AND mc.model_id LIKE '@cf/%'
     `,
   );
 
@@ -487,6 +488,7 @@ async function main() {
 
       console.log('Running catalog and config normalizations...');
       await query('DROP INDEX IF EXISTS repositories_owner_idx');
+      await query('CREATE INDEX IF NOT EXISTS repositories_owner_idx ON repositories (owner)');
       await ensureModelCatalog();
       await normalizeRepoConfigs();
 

scripts/setup-cloudflare.js

@@ -443,23 +443,25 @@ async function main() {
   let wranglerConfig = fs.readFileSync(WRANGLER_JSONC_PATH, 'utf-8');
   let configChanged = false;
 
+  const escapeJson = (str) => str.replace(/"/g, '\\"');
+
   const routeRegex = /"routes"\s*:\s*\[[\s\S]*?\]|"workers_dev"\s*:\s*(true|false)/;
   wranglerConfig = wranglerConfig.replace(routeRegex, routesConfigStr);
 
   const appUrlRegex = /"APP_URL":\s*"[^"]+"/;
-  wranglerConfig = wranglerConfig.replace(appUrlRegex, `"APP_URL": "${appUrl}"`);
+  wranglerConfig = wranglerConfig.replace(appUrlRegex, `"APP_URL": "${escapeJson(appUrl)}"`);
 
   const callbackUrlRegex = /"AUTH_CALLBACK_URL":\s*"[^"]+"/;
-  wranglerConfig = wranglerConfig.replace(callbackUrlRegex, `"AUTH_CALLBACK_URL": "${appUrl}/auth/github/callback"`);
+  wranglerConfig = wranglerConfig.replace(callbackUrlRegex, `"AUTH_CALLBACK_URL": "${escapeJson(appUrl)}/auth/github/callback"`);
 
   const botUsernameRegex = /"BOT_USERNAME":\s*"[^"]+"/;
-  wranglerConfig = wranglerConfig.replace(botUsernameRegex, `"BOT_USERNAME": "${botUsername}"`);
+  wranglerConfig = wranglerConfig.replace(botUsernameRegex, `"BOT_USERNAME": "${escapeJson(botUsername)}"`);
 
   const githubAppSlugRegex = /"GITHUB_APP_SLUG":\s*"[^"]+"/;
-  wranglerConfig = wranglerConfig.replace(githubAppSlugRegex, `"GITHUB_APP_SLUG": "${githubAppSlug}"`);
+  wranglerConfig = wranglerConfig.replace(githubAppSlugRegex, `"GITHUB_APP_SLUG": "${escapeJson(githubAppSlug)}"`);
 
   const allowedUsersRegex = /"DASHBOARD_ALLOWED_USERS":\s*"[^"]+"/;
-  wranglerConfig = wranglerConfig.replace(allowedUsersRegex, `"DASHBOARD_ALLOWED_USERS": "${allowedUsers}"`);
+  wranglerConfig = wranglerConfig.replace(allowedUsersRegex, `"DASHBOARD_ALLOWED_USERS": "${escapeJson(allowedUsers)}"`);
 
   configChanged = true;
 

src/server/core/github.ts

@@ -27,7 +27,7 @@ async function withRetry<T>(
       attempt++;
       const isSecondaryRateLimit = error instanceof GitHubError && 
         error.status === 403 && 
-        error.body.toLowerCase().includes('secondary rate limit');
+        error.body?.toLowerCase().includes('secondary rate limit');
 
       const isRetryable =
         isSecondaryRateLimit ||

src/server/core/model-output.ts

@@ -137,7 +137,9 @@ function extractJson(raw: string) {
     // Truncated JSON: the closing brace(s) are missing. Append them so jsonrepair
     // has a structurally complete (though incomplete-content) object to work with.
     const partial = raw.slice(firstBrace).trim();
-    const closing = '}'.repeat(Math.max(1, stack));
+    let closing = '';
+    if (inString) closing += '"';
+    closing += '}'.repeat(Math.max(1, stack));
     return `${partial}${closing}`;
   }
 
@@ -157,36 +159,37 @@ function coerceReviewNumber(value: unknown) {
   return undefined;
 }
 
-function normalizeFinding(finding: any) {
+function normalizeFinding(finding: unknown) {
   if (!finding || typeof finding !== 'object') return null;
-  if (isPlaceholderString(finding.title) || isPlaceholderString(finding.body)) return null;
+  const f = finding as Record<string, unknown>;
+  if (isPlaceholderString(f.title) || isPlaceholderString(f.body)) return null;
 
-  const location = finding.code_location && typeof finding.code_location === 'object' ? finding.code_location : {};
+  const location = f.code_location && typeof f.code_location === 'object' ? (f.code_location as Record<string, unknown>) : {};
   const line = coerceReviewNumber(location.line);
-  const start = coerceReviewNumber(location.line_range?.start);
-  const end = coerceReviewNumber(location.line_range?.end);
-  const priority = coerceReviewNumber(finding.priority);
+  const start = coerceReviewNumber(location.line_range && typeof location.line_range === 'object' ? (location.line_range as Record<string, unknown>).start : undefined);
+  const end = coerceReviewNumber(location.line_range && typeof location.line_range === 'object' ? (location.line_range as Record<string, unknown>).end : undefined);
+  const priority = coerceReviewNumber(f.priority);
 
   const codeLocation: Record<string, unknown> = {
-    absolute_file_path: location.absolute_file_path || finding.path || '',
+    absolute_file_path: location.absolute_file_path || f.path || '',
   };
   if (line !== undefined) {
-    codeLocation.line = Math.trunc(line);
+    codeLocation.line = Math.trunc(line as number);
   }
   if (start !== undefined || end !== undefined) {
     codeLocation.line_range = {
-      start: Math.trunc(start ?? end!),
-      end: Math.trunc(end ?? start!),
+      start: Math.trunc((start as number) ?? (end as number)!),
+      end: Math.trunc((end as number) ?? (start as number)!),
     };
   }
 
   return {
-    ...finding,
-    title: finding.title || 'Code finding',
-    priority: priority === undefined ? undefined : Math.max(0, Math.min(3, Math.trunc(priority))),
+    ...f,
+    title: f.title || 'Code finding',
+    priority: priority === undefined ? undefined : Math.max(0, Math.min(3, Math.trunc(priority as number))),
     code_location: codeLocation,
-    confidence_score: typeof finding.confidence_score === 'number'
-      ? Math.max(0, Math.min(1, finding.confidence_score > 1 ? finding.confidence_score / 10 : finding.confidence_score))
+    confidence_score: typeof f.confidence_score === 'number'
+      ? Math.max(0, Math.min(1, f.confidence_score > 1 ? f.confidence_score / 10 : f.confidence_score))
       : undefined,
   };
 }
@@ -288,7 +291,7 @@ export function parseFileReviewResponse(raw: string, file: FileDiff): {
     logger.warn('jsonrepair failed to fix model output, using preprocessed text', { preprocessed: truncateJsonForLog(preprocessed), error: e });
   }
 
-  let parsedJson: any;
+  let parsedJson: unknown;
   try {
     parsedJson = JSON.parse(repaired);
   } catch (e) {
@@ -298,13 +301,13 @@ export function parseFileReviewResponse(raw: string, file: FileDiff): {
 
   let parsed: z.infer<typeof fileReviewModelOutputSchema>;
   try {
-    const findReviewObject = (arr: any[]): any | null => {
+    const findReviewObject = (arr: unknown[]): unknown | null => {
       // Priority 1: Has findings array and summary
-      const best = arr.find(i => i && typeof i === 'object' && Array.isArray(i.findings) && typeof i.summary === 'string');
+      const best = arr.find(i => i && typeof i === 'object' && Array.isArray((i as Record<string, unknown>).findings) && typeof (i as Record<string, unknown>).summary === 'string');
       if (best) return best;
 
       // Priority 2: Has findings array
-      const good = arr.find(i => i && typeof i === 'object' && Array.isArray(i.findings));
+      const good = arr.find(i => i && typeof i === 'object' && Array.isArray((i as Record<string, unknown>).findings));
       if (good) return good;
 
       // Priority 3: Has review-like keys
@@ -314,29 +317,31 @@ export function parseFileReviewResponse(raw: string, file: FileDiff): {
       );
     };
 
-    const data = Array.isArray(parsedJson) ? (findReviewObject(parsedJson) || parsedJson[0] || {}) : parsedJson;
+    let data = Array.isArray(parsedJson) ? (findReviewObject(parsedJson) || parsedJson[0] || {}) : parsedJson;
 
     // Ensure essential keys exist to avoid schema validation errors
     if (data && typeof data === 'object') {
-      if (!data.findings) data.findings = [];
-      if (!data.overall_explanation) data.overall_explanation = 'No explanation provided.';
-      if (!data.overall_correctness) data.overall_correctness = 'Uncertain';
+      const obj = data as Record<string, unknown>;
+      if (!obj.findings) obj.findings = [];
+      if (!obj.overall_explanation) obj.overall_explanation = 'No explanation provided.';
+      if (!obj.overall_correctness) obj.overall_correctness = 'Uncertain';
 
       // Handle confidence score hallucinations (0-1 range expected)
-      if (typeof data.overall_confidence_score === 'number') {
-        if (data.overall_confidence_score > 1) {
+      if (typeof obj.overall_confidence_score === 'number') {
+        if (obj.overall_confidence_score > 1) {
           // If they gave 1-10 scale, normalize it
-          data.overall_confidence_score = Math.min(data.overall_confidence_score / 10, 1);
-        } else if (data.overall_confidence_score < 0) {
-          data.overall_confidence_score = 0;
+          obj.overall_confidence_score = Math.min(obj.overall_confidence_score / 10, 1);
+        } else if (obj.overall_confidence_score < 0) {
+          obj.overall_confidence_score = 0;
         }
       } else {
-        data.overall_confidence_score = 0.5;
+        obj.overall_confidence_score = 0.5;
       }
 
-      if (Array.isArray(data.findings)) {
-        data.findings = data.findings.map(normalizeFinding).filter(Boolean);
+      if (Array.isArray(obj.findings)) {
+        obj.findings = obj.findings.map(normalizeFinding).filter(Boolean);
       }
+      data = obj;
     }
 
     parsed = fileReviewModelOutputSchema.parse(data);

src/server/db/client.ts

@@ -5,6 +5,7 @@ import type { AppBindings } from '@server/env';
 type DbEnv = Pick<AppBindings, 'HYPERDRIVE'>;
 type DbClient = {
   query<T>(sqlText: string, params?: unknown[]): Promise<T[]>;
+  transaction<T>(fn: (tx: DbClient) => Promise<T>): Promise<T>;
 };
 
 const dbStorage = new AsyncLocalStorage<DbClient>();
@@ -21,6 +22,20 @@ function createDbClient(env: DbEnv): DbClient {
     async query<T>(sqlText: string, params: unknown[] = []) {
       return (await sql.unsafe(sqlText, params.map(normalizeParam) as any[], { prepare: false })) as T[];
     },
+    async transaction<T>(fn: (tx: DbClient) => Promise<T>) {
+      return (await sql.begin(async (t) => {
+        const txClient: DbClient = {
+          async query<U>(sqlText: string, params: unknown[] = []) {
+            return (await t.unsafe(sqlText, params.map(normalizeParam) as any[], { prepare: false })) as U[];
+          },
+          async transaction<U>(innerFn: (tx: DbClient) => Promise<U>) {
+            // Nested transactions could use savepoints, but for now we just reuse the same txClient
+            return await innerFn(txClient);
+          }
+        };
+        return await fn(txClient);
+      })) as T;
+    }
   };
 }
 
@@ -55,6 +70,10 @@ export async function queryRows<T>(env: DbEnv, sqlText: string, params: unknown[
   return getDb(env).query<T>(sqlText, params);
 }
 
+export async function queryTransaction<T>(env: DbEnv, fn: (tx: DbClient) => Promise<T>) {
+  return getDb(env).transaction<T>(fn);
+}
+
 export function parseJsonColumn<T>(value: T | string | null | undefined, fallback: T): T {
   if (value === null || value === undefined) return fallback;
   if (typeof value === 'string') return JSON.parse(value) as T;