@libredb/studio 0.9.7

package/render.yaml

@@ -0,0 +1,58 @@
+# Render Blueprint - Infrastructure as Code
+# https://render.com/docs/blueprint-spec
+
+services:
+  - type: web
+    name: libredb-studio
+    runtime: docker
+    # Use Dockerfile for building
+    dockerfilePath: ./Dockerfile
+    # Health check endpoint
+    healthCheckPath: /api/db/health
+    # Auto-deploy on push to main
+    autoDeploy: true
+    # Environment variables (set in Render Dashboard for secrets)
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: PORT
+        value: 3000
+      # Authentication - Set these in Render Dashboard
+      - key: ADMIN_EMAIL
+        sync: false
+      - key: ADMIN_PASSWORD
+        sync: false # Must be set manually in dashboard
+      - key: USER_EMAIL
+        sync: false
+      - key: USER_PASSWORD
+        sync: false
+      - key: JWT_SECRET
+        sync: false # Must be at least 32 characters
+      # OIDC / SSO Configuration - Set in Dashboard
+      - key: NEXT_PUBLIC_AUTH_PROVIDER
+        value: oidc # or "local" for password-based auth
+      - key: OIDC_ISSUER
+        sync: false
+      - key: OIDC_CLIENT_ID
+        sync: false
+      - key: OIDC_CLIENT_SECRET
+        sync: false
+      - key: OIDC_SCOPE
+        value: openid profile email
+      - key: OIDC_ROLE_CLAIM
+        sync: false
+      - key: OIDC_ADMIN_ROLES
+        value: admin
+      # AI Configuration (Optional) - Set in Dashboard
+      - key: LLM_PROVIDER
+        value: gemini
+      - key: LLM_API_KEY
+        sync: false
+      - key: LLM_MODEL
+        value: gemini-2.5-flash
+    # Disk for persistent storage (optional)
+    # disk:
+    #   name: libredb-data
+    #   mountPath: /app/data
+    #   sizeGB: 1
+

package/scripts/merge-lcov.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function parseLcov(content) {
+  const records = [];
+  const rawRecords = content.split("end_of_record");
+
+  for (const raw of rawRecords) {
+    const lines = raw
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    if (lines.length === 0) {
+      continue;
+    }
+
+    const record = {
+      sf: "",
+      functions: new Map(),
+      functionHits: new Map(),
+      lines: new Map(),
+      branches: new Map(),
+    };
+
+    for (const line of lines) {
+      if (line.startsWith("SF:")) {
+        record.sf = line.slice(3);
+        continue;
+      }
+
+      if (line.startsWith("FN:")) {
+        const payload = line.slice(3);
+        const commaIndex = payload.indexOf(",");
+        if (commaIndex >= 0) {
+          const lineNumber = Number(payload.slice(0, commaIndex));
+          const functionName = payload.slice(commaIndex + 1);
+          record.functions.set(functionName, Number.isFinite(lineNumber) ? lineNumber : 0);
+        }
+        continue;
+      }
+
+      if (line.startsWith("FNDA:")) {
+        const payload = line.slice(5);
+        const commaIndex = payload.indexOf(",");
+        if (commaIndex >= 0) {
+          const hits = Number(payload.slice(0, commaIndex)) || 0;
+          const functionName = payload.slice(commaIndex + 1);
+          record.functionHits.set(functionName, hits);
+        }
+        continue;
+      }
+
+      if (line.startsWith("DA:")) {
+        const payload = line.slice(3);
+        const commaIndex = payload.indexOf(",");
+        if (commaIndex >= 0) {
+          const lineNumber = Number(payload.slice(0, commaIndex));
+          const hits = Number(payload.slice(commaIndex + 1)) || 0;
+          if (Number.isFinite(lineNumber)) {
+            record.lines.set(lineNumber, hits);
+          }
+        }
+        continue;
+      }
+
+      if (line.startsWith("BRDA:")) {
+        const payload = line.slice(5);
+        const [lineNoRaw, blockNoRaw, branchNoRaw, takenRaw] = payload.split(",");
+        const lineNo = Number(lineNoRaw);
+        const blockNo = Number(blockNoRaw);
+        const branchNo = Number(branchNoRaw);
+        const key = `${lineNo},${blockNo},${branchNo}`;
+        const taken = takenRaw === "-" ? -1 : Number(takenRaw) || 0;
+        if (Number.isFinite(lineNo) && Number.isFinite(blockNo) && Number.isFinite(branchNo)) {
+          record.branches.set(key, taken);
+        }
+      }
+    }
+
+    if (record.sf) {
+      records.push(record);
+    }
+  }
+
+  return records;
+}
+
+function mergeRecords(inputRecords) {
+  const byFile = new Map();
+
+  for (const record of inputRecords) {
+    const existing = byFile.get(record.sf) || {
+      sf: record.sf,
+      functions: new Map(),
+      functionHits: new Map(),
+      lines: new Map(),
+      branches: new Map(),
+    };
+
+    for (const [fnName, fnLine] of record.functions.entries()) {
+      if (!existing.functions.has(fnName)) {
+        existing.functions.set(fnName, fnLine);
+      }
+    }
+
+    for (const [fnName, hits] of record.functionHits.entries()) {
+      const prevHits = existing.functionHits.get(fnName) || 0;
+      existing.functionHits.set(fnName, Math.max(prevHits, hits));
+    }
+
+    for (const [lineNo, hits] of record.lines.entries()) {
+      const prevHits = existing.lines.get(lineNo) || 0;
+      existing.lines.set(lineNo, Math.max(prevHits, hits));
+    }
+
+    for (const [key, taken] of record.branches.entries()) {
+      const prevTaken = existing.branches.has(key) ? existing.branches.get(key) : -1;
+      if (prevTaken === -1 && taken !== -1) {
+        existing.branches.set(key, taken);
+      } else if (prevTaken !== -1 && taken === -1) {
+        existing.branches.set(key, prevTaken);
+      } else {
+        existing.branches.set(key, Math.max(prevTaken, taken));
+      }
+    }
+
+    byFile.set(record.sf, existing);
+  }
+
+  return [...byFile.values()].sort((a, b) => a.sf.localeCompare(b.sf));
+}
+
+function serializeRecords(records) {
+  const chunks = [];
+
+  for (const record of records) {
+    const lines = [];
+    lines.push(`SF:${record.sf}`);
+
+    const sortedFunctions = [...record.functions.entries()].sort((a, b) => a[1] - b[1]);
+    for (const [fnName, fnLine] of sortedFunctions) {
+      lines.push(`FN:${fnLine},${fnName}`);
+    }
+
+    for (const [fnName] of sortedFunctions) {
+      const hits = record.functionHits.get(fnName) || 0;
+      lines.push(`FNDA:${hits},${fnName}`);
+    }
+
+    const fnf = sortedFunctions.length;
+    const fnh = sortedFunctions.reduce((acc, [fnName]) => acc + ((record.functionHits.get(fnName) || 0) > 0 ? 1 : 0), 0);
+    lines.push(`FNF:${fnf}`);
+    lines.push(`FNH:${fnh}`);
+
+    const sortedLineEntries = [...record.lines.entries()].sort((a, b) => a[0] - b[0]);
+    for (const [lineNo, hits] of sortedLineEntries) {
+      lines.push(`DA:${lineNo},${hits}`);
+    }
+
+    const lf = sortedLineEntries.length;
+    const lh = sortedLineEntries.reduce((acc, [, hits]) => acc + (hits > 0 ? 1 : 0), 0);
+    lines.push(`LF:${lf}`);
+    lines.push(`LH:${lh}`);
+
+    if (record.branches.size > 0) {
+      const sortedBranchEntries = [...record.branches.entries()].sort((a, b) => {
+        const [aLine, aBlock, aBranch] = a[0].split(",").map(Number);
+        const [bLine, bBlock, bBranch] = b[0].split(",").map(Number);
+        if (aLine !== bLine) return aLine - bLine;
+        if (aBlock !== bBlock) return aBlock - bBlock;
+        return aBranch - bBranch;
+      });
+
+      for (const [key, taken] of sortedBranchEntries) {
+        const takenValue = taken < 0 ? "-" : String(taken);
+        lines.push(`BRDA:${key},${takenValue}`);
+      }
+
+      const brf = sortedBranchEntries.length;
+      const brh = sortedBranchEntries.reduce((acc, [, taken]) => acc + (taken > 0 ? 1 : 0), 0);
+      lines.push(`BRF:${brf}`);
+      lines.push(`BRH:${brh}`);
+    }
+
+    lines.push("end_of_record");
+    chunks.push(lines.join("\n"));
+  }
+
+  return chunks.join("\n");
+}
+
+function main() {
+  const [, , ...args] = process.argv;
+  if (args.length < 3) {
+    console.error("Usage: node scripts/merge-lcov.mjs <input1> <input2> [moreInputs...] <output>");
+    process.exit(1);
+  }
+
+  const outputPath = args[args.length - 1];
+  const inputPaths = args.slice(0, -1);
+  const allRecords = [];
+
+  for (const inputPath of inputPaths) {
+    const content = fs.readFileSync(inputPath, "utf8");
+    allRecords.push(...parseLcov(content));
+  }
+
+  const merged = mergeRecords(allRecords);
+
+  // Filter out non-source files that SonarCloud can't resolve:
+  // - tests/ and e2e/ directories (test infrastructure, not source)
+  // - src/components/ui/ (excluded in sonar.exclusions)
+  const filtered = merged.filter((r) => {
+    if (!r.sf.startsWith("src/")) return false;
+    if (r.sf.startsWith("src/components/ui/")) return false;
+    return true;
+  });
+
+  const skipped = merged.length - filtered.length;
+  if (skipped > 0) {
+    console.log(`Filtered ${skipped} non-source record(s) (tests/, src/components/ui/)`);
+  }
+
+  const serialized = serializeRecords(filtered);
+
+  ensureParentDir(outputPath);
+  fs.writeFileSync(outputPath, serialized ? `${serialized}\n` : "", "utf8");
+  console.log(`Merged ${inputPaths.length} LCOV file(s) into ${outputPath}`);
+  console.log(`Records: ${merged.length}`);
+}
+
+main();

package/sonar-project.properties

@@ -0,0 +1,16 @@
+sonar.projectKey=libredb_libredb-studio
+sonar.organization=libredb
+
+sonar.projectName=libredb-studio
+sonar.projectVersion=0.6.38
+
+sonar.sources=src
+sonar.tests=tests,e2e
+sonar.test.inclusions=tests/**/*.test.ts,tests/**/*.test.tsx,e2e/**/*.spec.ts
+
+# Exclude only runtime/generated code, NOT test files
+sonar.exclusions=**/node_modules/**,**/.next/**,**/build/**,**/out/**,src/components/ui/**
+
+sonar.javascript.lcov.reportPaths=coverage/lcov.info
+sonar.typescript.tsconfigPath=tsconfig.json
+sonar.sourceEncoding=UTF-8

package/src/app/admin/error.tsx

@@ -0,0 +1,46 @@
+'use client';
+
+import { useEffect } from 'react';
+
+export default function AdminError({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  useEffect(() => {
+    console.error('[AdminErrorBoundary]', error.message, error.digest);
+  }, [error]);
+
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-zinc-950 text-white">
+      <div className="max-w-md text-center px-6">
+        <h1 className="text-xl font-semibold mb-2">Admin Dashboard Error</h1>
+        <p className="text-zinc-400 mb-6 text-sm">
+          The admin dashboard encountered an error. You can try again or return
+          to the main studio.
+        </p>
+        {error.digest && (
+          <p className="text-zinc-600 text-xs mb-4">
+            Error ID: {error.digest}
+          </p>
+        )}
+        <div className="flex gap-3 justify-center">
+          <button
+            onClick={reset}
+            className="px-5 py-2.5 bg-blue-600 hover:bg-blue-700 text-white rounded-lg text-sm font-medium transition-colors"
+          >
+            Try Again
+          </button>
+          <button
+            onClick={() => { window.location.href = '/'; }}
+            className="px-5 py-2.5 border border-zinc-700 hover:border-zinc-500 text-zinc-300 rounded-lg text-sm font-medium transition-colors"
+          >
+            Back to Studio
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

package/src/app/admin/page.tsx

@@ -0,0 +1,10 @@
+import { Suspense } from 'react';
+import AdminDashboard from '@/components/admin/AdminDashboard';
+
+export default function AdminPage() {
+  return (
+    <Suspense>
+      <AdminDashboard />
+    </Suspense>
+  );
+}

package/src/app/api/admin/audit/route.ts

@@ -0,0 +1,52 @@
+import { getSession } from '@/lib/auth';
+import { NextResponse } from 'next/server';
+import { getServerAuditBuffer, type AuditEventType } from '@/lib/audit';
+import { createErrorResponse } from '@/lib/api/errors';
+
+export async function GET(request: Request) {
+  try {
+    const session = await getSession();
+    if (!session || session.role !== 'admin') {
+      return NextResponse.json(
+        { error: 'Unauthorized. Admin access required.' },
+        { status: 403 }
+      );
+    }
+
+    const { searchParams } = new URL(request.url);
+    const type = searchParams.get('type') as AuditEventType | null;
+    const limit = parseInt(searchParams.get('limit') || '100', 10);
+
+    const buffer = getServerAuditBuffer();
+    const events = type
+      ? buffer.filter({ type })
+      : buffer.getRecent(limit);
+
+    return NextResponse.json({ events, total: buffer.size });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'GET /api/admin/audit' });
+  }
+}
+
+export async function POST(request: Request) {
+  const session = await getSession();
+  if (!session || session.role !== 'admin') {
+    return NextResponse.json(
+      { error: 'Unauthorized. Admin access required.' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const event = await request.json();
+    const buffer = getServerAuditBuffer();
+    const created = buffer.push({
+      ...event,
+      user: session.username || 'admin',
+    });
+
+    return NextResponse.json({ event: created });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'POST /api/admin/audit' });
+  }
+}

package/src/app/api/admin/fleet-health/route.ts

@@ -0,0 +1,81 @@
+import { getSession } from '@/lib/auth';
+import { NextResponse } from 'next/server';
+import { getOrCreateProvider } from '@/lib/db';
+import type { DatabaseConnection } from '@/lib/types';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+
+export interface FleetHealthItem {
+  connectionId: string;
+  connectionName: string;
+  type: string;
+  environment?: string;
+  status: 'healthy' | 'degraded' | 'error';
+  latencyMs: number;
+  activeConnections?: number;
+  databaseSize?: string;
+  error?: string;
+}
+
+export async function POST(request: Request) {
+  const session = await getSession();
+  if (!session || session.role !== 'admin') {
+    return NextResponse.json(
+      { error: 'Unauthorized. Admin access required.' },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const { connections } = (await request.json()) as {
+      connections: DatabaseConnection[];
+    };
+
+    if (!connections || !Array.isArray(connections)) {
+      return NextResponse.json(
+        { error: 'connections array is required' },
+        { status: 400 }
+      );
+    }
+
+    const results: FleetHealthItem[] = await Promise.all(
+      connections.map(async (conn): Promise<FleetHealthItem> => {
+        const start = Date.now();
+        try {
+          // Resolve managed seed connections (server-side credential injection)
+          const resolved = conn.managed && conn.seedId
+            ? await resolveConnection({ connectionId: `seed:${conn.seedId}` }, session!)
+            : conn;
+          const provider = await getOrCreateProvider(resolved);
+          const health = await provider.getHealth();
+          const latencyMs = Date.now() - start;
+
+          return {
+            connectionId: conn.id,
+            connectionName: conn.name,
+            type: conn.type,
+            environment: conn.environment,
+            status: latencyMs > 5000 ? 'degraded' : 'healthy',
+            latencyMs,
+            activeConnections: health.activeConnections,
+            databaseSize: health.databaseSize,
+          };
+        } catch (err) {
+          return {
+            connectionId: conn.id,
+            connectionName: conn.name,
+            type: conn.type,
+            environment: conn.environment,
+            status: 'error',
+            latencyMs: Date.now() - start,
+            error: err instanceof Error ? err.message : 'Connection failed',
+          };
+        }
+      })
+    );
+
+    return NextResponse.json({ results });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'POST /api/admin/fleet-health' });
+  }
+}

package/src/app/api/ai/autopilot/route.ts

@@ -0,0 +1,105 @@
+import { NextRequest } from 'next/server';
+import { createLLMProvider } from '@/lib/llm';
+import { createErrorResponse } from '@/lib/api/errors';
+
+function buildAutopilotPrompt(databaseType: string): string {
+  return `You are a Database Performance Autopilot for ${databaseType || 'PostgreSQL'}. You combine slow query analysis, execution plans, table statistics, and index usage into a comprehensive optimization report.
+
+OUTPUT FORMAT (markdown):
+
+## Performance Score
+Give a score out of 100 based on the overall health metrics. Use emoji: >=80 green, 60-79 yellow, <60 red.
+
+## Critical Issues
+Issues that need immediate attention (blocking queries, high bloat, cache miss rates).
+
+## Top Slow Queries
+For each slow query (top 5):
+### Query #N
+- **Avg Time:** Xms (Y calls)
+- **Issue:** What's making it slow
+- **Fix:**
+\`\`\`sql
+-- Optimized version or CREATE INDEX suggestion
+\`\`\`
+
+## Index Recommendations
+Consolidated index suggestions from the slow query analysis.
+
+## Maintenance Tasks
+Recommended VACUUM, ANALYZE, REINDEX operations with priority.
+
+## Configuration Suggestions
+Any ${databaseType} configuration parameters that might improve performance based on the metrics.
+
+## Action Plan
+Numbered priority list of what to do first, second, third.
+
+GUIDELINES:
+- Be actionable: every recommendation should have a concrete SQL command
+- Prioritize by impact: fix the biggest bottleneck first
+- Consider trade-offs: new indexes use space, VACUUM needs downtime
+- For ${databaseType}, use database-specific features and best practices
+`;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const {
+      slowQueries,
+      indexStats,
+      tableStats,
+      performanceMetrics,
+      overview,
+      schemaContext,
+      databaseType
+    } = await req.json();
+
+    const provider = await createLLMProvider();
+    const systemPrompt = buildAutopilotPrompt(databaseType);
+
+    const parts: string[] = [];
+
+    if (overview) {
+      parts.push('## Database Overview\n' + JSON.stringify(overview, null, 2));
+    }
+
+    if (performanceMetrics) {
+      parts.push('## Performance Metrics\n' + JSON.stringify(performanceMetrics, null, 2));
+    }
+
+    if (slowQueries?.length) {
+      parts.push('## Slow Queries (Top 20)\n' + JSON.stringify(slowQueries.slice(0, 20), null, 2));
+    }
+
+    if (indexStats?.length) {
+      parts.push('## Index Statistics\n' + JSON.stringify(indexStats.slice(0, 50), null, 2));
+    }
+
+    if (tableStats?.length) {
+      parts.push('## Table Statistics\n' + JSON.stringify(tableStats.slice(0, 30), null, 2));
+    }
+
+    if (schemaContext) {
+      parts.push('## Schema\n' + schemaContext.substring(0, 3000));
+    }
+
+    const userMessage = `Analyze the following database metrics and provide a comprehensive performance optimization report:\n\n${parts.join('\n\n')}`;
+
+    const stream = await provider.stream({
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userMessage },
+      ],
+    });
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/plain; charset=utf-8',
+        'Transfer-Encoding': 'chunked',
+      },
+    });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'api/ai/autopilot' });
+  }
+}