@libredb/studio 0.9.7

package/src/app/api/db/profile/route.ts

@@ -0,0 +1,144 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getOrCreateProvider } from '@/lib/db/factory';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { tableName, columns } = body;
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    const connection = await resolveConnection(body, session);
+
+    if (!tableName) {
+      return NextResponse.json({ error: 'tableName is required' }, { status: 400 });
+    }
+
+    const provider = await getOrCreateProvider(connection);
+
+    {
+      const capabilities = provider.getCapabilities();
+      const isSQL = capabilities.queryLanguage === 'sql';
+
+      if (!isSQL) {
+        // MongoDB profiling
+        const profileQuery = JSON.stringify({
+          collection: tableName,
+          operation: 'aggregate',
+          pipeline: [
+            { $sample: { size: 1000 } },
+            { $project: Object.fromEntries((columns || []).map((c: string) => [c, 1])) },
+          ],
+        });
+        const sampleResult = await provider.query(profileQuery);
+        const totalCountResult = await provider.query(JSON.stringify({
+          collection: tableName,
+          operation: 'countDocuments',
+          filter: {},
+        }));
+
+        const totalRows = totalCountResult.rows[0]?.count || sampleResult.rows.length;
+        const columnProfiles = (columns || []).map((col: string) => {
+          const values = sampleResult.rows.map(r => r[col]).filter(v => v !== undefined);
+          const nullCount = sampleResult.rows.length - values.length;
+          const distinctValues = new Set(values.map(v => JSON.stringify(v)));
+
+          return {
+            name: col,
+            type: typeof values[0] || 'unknown',
+            totalRows,
+            nullCount,
+            nullPercent: sampleResult.rows.length > 0 ? Math.round((nullCount / sampleResult.rows.length) * 100) : 0,
+            distinctCount: distinctValues.size,
+            sampleValues: values.slice(0, 5).map(v => String(v)),
+          };
+        });
+
+        return NextResponse.json({ tableName, totalRows, columns: columnProfiles });
+      }
+
+      // SQL profiling
+      const colList = (columns || []) as string[];
+      if (colList.length === 0) {
+        return NextResponse.json({ error: 'No columns to profile' }, { status: 400 });
+      }
+
+      // Get total row count
+      const countResult = await provider.query(`SELECT COUNT(*) as total FROM ${tableName}`);
+      const totalRows = Number(countResult.rows[0]?.total || 0);
+
+      // Build profiling query for each column
+      const profileParts = colList.slice(0, 20).map((col) => {
+        const safeCol = `"${col}"`;
+        return `
+          SELECT
+            '${col.replace(/'/g, "''")}' as column_name,
+            COUNT(*) as total_count,
+            COUNT(${safeCol}) as non_null_count,
+            COUNT(*) - COUNT(${safeCol}) as null_count,
+            COUNT(DISTINCT ${safeCol}) as distinct_count,
+            MIN(${safeCol}::text) as min_value,
+            MAX(${safeCol}::text) as max_value
+          FROM ${tableName}
+        `;
+      });
+
+      const columnProfiles: { name: string; totalRows: number; nullCount: number; nullPercent: number; distinctCount: number; minValue?: unknown; maxValue?: unknown; error?: string; sampleValues?: string[] }[] = [];
+
+      for (const sql of profileParts) {
+        try {
+          const result = await provider.query(sql);
+          const row = result.rows[0];
+          if (row) {
+            const nullCount = Number(row.null_count || 0);
+            const total = Number(row.total_count || 0);
+
+            columnProfiles.push({
+              name: String(row.column_name),
+              totalRows: total,
+              nullCount,
+              nullPercent: total > 0 ? Math.round((nullCount / total) * 100) : 0,
+              distinctCount: Number(row.distinct_count || 0),
+              minValue: row.min_value,
+              maxValue: row.max_value,
+            });
+          }
+        } catch {
+          // Skip columns that can't be profiled (e.g., binary)
+          columnProfiles.push({
+            name: colList[columnProfiles.length],
+            totalRows,
+            nullCount: 0,
+            nullPercent: 0,
+            distinctCount: 0,
+            error: 'Could not profile this column',
+          });
+        }
+      }
+
+      // Get sample values for top 5 columns
+      const topCols = colList.slice(0, 5);
+      const safeCols = topCols.map(c => `"${c}"`).join(', ');
+      try {
+        const sampleResult = await provider.query(
+          `SELECT ${safeCols} FROM ${tableName} LIMIT 5`
+        );
+        for (const profile of columnProfiles) {
+          if (topCols.includes(profile.name)) {
+            profile.sampleValues = sampleResult.rows.map(r => String(r[profile.name] ?? 'NULL')).slice(0, 5);
+          }
+        }
+      } catch { /* skip sample values on error */ }
+
+      return NextResponse.json({ tableName, totalRows, columns: columnProfiles });
+    }
+  } catch (error) {
+    return createErrorResponse(error, { route: 'api/db/profile' });
+  }
+}

package/src/app/api/db/provider-meta/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getOrCreateProvider } from '@/lib/db';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: NextRequest) {
+  try {
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return NextResponse.json({ error: 'Empty request body' }, { status: 400 });
+    }
+
+    if (!body || (typeof body === 'object' && Object.keys(body).length === 0)) {
+      return NextResponse.json({ error: 'Empty request body' }, { status: 400 });
+    }
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    // Support both formats: { connectionId: "seed:X" }, { connection: {...} }, or bare connection object
+    const connection = await resolveConnection(
+      body.connectionId ? body : (body.connection ? body : { connection: body }),
+      session,
+    );
+
+    if (!connection.type) {
+      return NextResponse.json(
+        { error: 'Valid connection configuration is required' },
+        { status: 400 }
+      );
+    }
+
+    const provider = await getOrCreateProvider(connection);
+
+    return NextResponse.json({
+      capabilities: provider.getCapabilities(),
+      labels: provider.getLabels(),
+    });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'api/db/provider-meta' });
+  }
+}

package/src/app/api/db/query/route.ts

@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getOrCreateProvider } from '@/lib/db';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { sql, options = {}, queryId } = body;
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    const connection = await resolveConnection(body, session);
+
+    if (!sql) {
+      return NextResponse.json(
+        { error: 'Connection and query are required' },
+        { status: 400 }
+      );
+    }
+
+    const provider = await getOrCreateProvider(connection);
+    const prepared = provider.prepareQuery(sql, options);
+
+    // Pass queryId to provider for cancellation tracking
+    const supportsCancel = 'cancelQuery' in provider;
+    const result = supportsCancel && queryId
+      ? await (provider as unknown as { query(sql: string, params?: unknown[], queryId?: string): ReturnType<typeof provider.query> }).query(prepared.query, undefined, queryId)
+      : await provider.query(prepared.query);
+
+    const hasMore = result.rows.length === prepared.limit;
+
+    return NextResponse.json({
+      ...result,
+      pagination: {
+        limit: prepared.limit,
+        offset: prepared.offset,
+        hasMore,
+        totalReturned: result.rows.length,
+        wasLimited: prepared.wasLimited,
+      },
+    });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'api/db/query' });
+  }
+}

package/src/app/api/db/schema/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getOrCreateProvider } from '@/lib/db';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: NextRequest) {
+  try {
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return NextResponse.json({ error: 'Empty request body' }, { status: 400 });
+    }
+
+    if (!body || (typeof body === 'object' && Object.keys(body).length === 0)) {
+      return NextResponse.json({ error: 'Empty request body' }, { status: 400 });
+    }
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    // Support both formats: { connectionId: "seed:X" }, { connection: {...} }, or bare connection object
+    const connection = await resolveConnection(
+      body.connectionId ? body : (body.connection ? body : { connection: body }),
+      session,
+    );
+
+    if (!connection.type) {
+      return NextResponse.json(
+        { error: 'Valid connection configuration is required' },
+        { status: 400 }
+      );
+    }
+
+    const provider = await getOrCreateProvider(connection);
+    const schema = await provider.getSchema();
+
+    return NextResponse.json(schema);
+  } catch (error) {
+    return createErrorResponse(error, { route: 'api/db/schema' });
+  }
+}

package/src/app/api/db/schema-snapshot/route.ts

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createDatabaseProvider } from '@/lib/db/factory';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+export async function POST(request: NextRequest) {
+  let provider = null;
+
+  try {
+    const body = await request.json();
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    const connection = await resolveConnection(body, session);
+
+    provider = await createDatabaseProvider(connection);
+    await provider.connect();
+
+    const schema = await provider.getSchema();
+
+    await provider.disconnect();
+    provider = null;
+
+    return NextResponse.json({
+      schema,
+      connectionId: connection.id,
+      connectionName: connection.name,
+      databaseType: connection.type,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (error) {
+    if (provider) {
+      try { await provider.disconnect(); } catch { /* ignore */ }
+    }
+
+    return createErrorResponse(error, { route: 'api/db/schema-snapshot' });
+  }
+}

package/src/app/api/db/test-connection/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createDatabaseProvider } from '@/lib/db/factory';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+export async function POST(req: NextRequest) {
+  let provider = null;
+
+  try {
+    const body = await req.json();
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    // Support both formats: { connectionId: "seed:X" }, { connection: {...} }, or bare connection object
+    const connection = await resolveConnection(
+      body.connectionId ? body : (body.connection ? body : { connection: body }),
+      session,
+    );
+
+    if (!connection.type) {
+      return NextResponse.json(
+        { success: false, error: 'Connection configuration is required' },
+        { status: 400 }
+      );
+    }
+
+    provider = await createDatabaseProvider(connection, { queryTimeout: 10000 });
+    await provider.connect();
+
+    // Run a lightweight query to verify the connection actually works
+    const startTime = Date.now();
+    await provider.getHealth();
+    const latency = Date.now() - startTime;
+
+    await provider.disconnect();
+    provider = null;
+
+    return NextResponse.json({
+      success: true,
+      message: 'Connection successful',
+      latency,
+    });
+  } catch (error) {
+    // Ensure we disconnect on error
+    if (provider) {
+      try { await provider.disconnect(); } catch { /* ignore */ }
+    }
+
+    return createErrorResponse(error, { route: 'api/db/test-connection' });
+  }
+}

package/src/app/api/db/transaction/route.ts

@@ -0,0 +1,111 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getOrCreateProvider } from '@/lib/db';
+import { createErrorResponse } from '@/lib/api/errors';
+import { resolveConnection } from '@/lib/seed/resolve-connection';
+import { getSession } from '@/lib/auth';
+
+interface TransactionProvider {
+  beginTransaction(): Promise<void>;
+  commitTransaction(): Promise<void>;
+  rollbackTransaction(): Promise<void>;
+  isInTransaction(): boolean;
+  queryInTransaction(sql: string, params?: unknown[]): Promise<{ rows: Record<string, unknown>[]; fields: string[]; rowCount: number; executionTime: number }>;
+}
+
+function isTransactionProvider(provider: unknown): provider is TransactionProvider {
+  return (
+    typeof provider === 'object' &&
+    provider !== null &&
+    'beginTransaction' in provider &&
+    'commitTransaction' in provider &&
+    'rollbackTransaction' in provider
+  );
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { action, sql, options = {} } = body;
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+    }
+
+    const connection = await resolveConnection(body, session);
+
+    if (!action) {
+      return NextResponse.json(
+        { error: 'Connection and action are required' },
+        { status: 400 }
+      );
+    }
+
+    const provider = await getOrCreateProvider(connection);
+
+    if (!isTransactionProvider(provider)) {
+      return NextResponse.json(
+        { error: 'Transaction control is not supported for this database type' },
+        { status: 400 }
+      );
+    }
+
+    switch (action) {
+      case 'begin': {
+        await provider.beginTransaction();
+        return NextResponse.json({ status: 'active', message: 'Transaction started' });
+      }
+
+      case 'commit': {
+        await provider.commitTransaction();
+        return NextResponse.json({ status: 'committed', message: 'Transaction committed' });
+      }
+
+      case 'rollback': {
+        await provider.rollbackTransaction();
+        return NextResponse.json({ status: 'rolled_back', message: 'Transaction rolled back' });
+      }
+
+      case 'query': {
+        if (!sql) {
+          return NextResponse.json(
+            { error: 'SQL query is required for transaction query' },
+            { status: 400 }
+          );
+        }
+
+        // Apply limit for SELECT queries within transaction
+        const prepared = provider.prepareQuery(sql, options);
+        const result = await provider.queryInTransaction(prepared.query);
+
+        const hasMore = result.rows.length === prepared.limit;
+
+        return NextResponse.json({
+          ...result,
+          inTransaction: true,
+          pagination: {
+            limit: prepared.limit,
+            offset: prepared.offset,
+            hasMore,
+            totalReturned: result.rows.length,
+            wasLimited: prepared.wasLimited,
+          },
+        });
+      }
+
+      case 'status': {
+        return NextResponse.json({
+          inTransaction: provider.isInTransaction(),
+        });
+      }
+
+      default:
+        return NextResponse.json(
+          { error: `Unknown transaction action: ${action}. Valid: begin, commit, rollback, query, status` },
+          { status: 400 }
+        );
+    }
+  } catch (error) {
+    return createErrorResponse(error, { route: 'api/db/transaction' });
+  }
+}

package/src/app/api/storage/[collection]/route.ts

@@ -0,0 +1,67 @@
+/**
+ * PUT /api/storage/[collection]
+ * Updates a single storage collection for the authenticated user.
+ * Only works when server storage is enabled.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { getSession } from '@/lib/auth';
+import { getStorageProvider } from '@/lib/storage/factory';
+import { STORAGE_COLLECTIONS, type StorageCollection } from '@/lib/storage/types';
+import { createErrorResponse } from '@/lib/api/errors';
+
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ collection: string }> }
+) {
+  try {
+    const provider = await getStorageProvider();
+    if (!provider) {
+      return NextResponse.json(
+        { error: 'Server storage is not enabled' },
+        { status: 404 }
+      );
+    }
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const { collection } = await params;
+
+    if (!STORAGE_COLLECTIONS.includes(collection as StorageCollection)) {
+      return NextResponse.json(
+        { error: `Invalid collection: ${collection}` },
+        { status: 400 }
+      );
+    }
+
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return NextResponse.json(
+        { error: 'Invalid JSON in request body' },
+        { status: 400 }
+      );
+    }
+
+    if (body.data === undefined || body.data === null) {
+      return NextResponse.json(
+        { error: 'Missing required field: data' },
+        { status: 400 }
+      );
+    }
+
+    await provider.setCollection(
+      session.username,
+      collection as StorageCollection,
+      body.data
+    );
+
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'PUT /api/storage/[collection]' });
+  }
+}

package/src/app/api/storage/config/route.ts

@@ -0,0 +1,17 @@
+/**
+ * GET /api/storage/config
+ * Returns storage configuration (public endpoint, no auth required).
+ * Client uses this to discover if server-side storage is enabled at runtime.
+ */
+
+import { NextResponse } from 'next/server';
+import { getStorageConfig } from '@/lib/storage/factory';
+import { createErrorResponse } from '@/lib/api/errors';
+
+export async function GET() {
+  try {
+    return NextResponse.json(getStorageConfig());
+  } catch (error) {
+    return createErrorResponse(error, { route: 'GET /api/storage/config' });
+  }
+}

package/src/app/api/storage/migrate/route.ts

@@ -0,0 +1,45 @@
+/**
+ * POST /api/storage/migrate
+ * Migrates localStorage data to server storage.
+ * Client sends all its localStorage collections; server merges them.
+ * Only works when server storage is enabled.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { getSession } from '@/lib/auth';
+import { getStorageProvider } from '@/lib/storage/factory';
+import type { StorageData } from '@/lib/storage/types';
+import { createErrorResponse } from '@/lib/api/errors';
+
+export async function POST(request: NextRequest) {
+  try {
+    const provider = await getStorageProvider();
+    if (!provider) {
+      return NextResponse.json(
+        { error: 'Server storage is not enabled' },
+        { status: 404 }
+      );
+    }
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    let body: Partial<StorageData>;
+    try {
+      body = (await request.json()) as Partial<StorageData>;
+    } catch {
+      return NextResponse.json(
+        { error: 'Invalid JSON in request body' },
+        { status: 400 }
+      );
+    }
+
+    await provider.mergeData(session.username, body);
+
+    return NextResponse.json({ ok: true, migrated: Object.keys(body) });
+  } catch (error) {
+    return createErrorResponse(error, { route: 'POST /api/storage/migrate' });
+  }
+}

package/src/app/api/storage/route.ts

@@ -0,0 +1,32 @@
+/**
+ * GET /api/storage
+ * Returns all storage data for the authenticated user.
+ * Only works when server storage is enabled.
+ */
+
+import { NextResponse } from 'next/server';
+import { getSession } from '@/lib/auth';
+import { getStorageProvider } from '@/lib/storage/factory';
+import { createErrorResponse } from '@/lib/api/errors';
+
+export async function GET() {
+  try {
+    const provider = await getStorageProvider();
+    if (!provider) {
+      return NextResponse.json(
+        { error: 'Server storage is not enabled' },
+        { status: 404 }
+      );
+    }
+
+    const session = await getSession();
+    if (!session) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const data = await provider.getAllData(session.username);
+    return NextResponse.json(data);
+  } catch (error) {
+    return createErrorResponse(error, { route: 'GET /api/storage' });
+  }
+}