d1s 0.2.13 → 0.3.1

package/dist/app/api/tables/[name]/route.js

@@ -5,7 +5,9 @@ import { promisify } from 'util';
 import { exec } from 'child_process';
 import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
 import { dbQueue } from '@/lib/database-queue';
+import { executeLocalSQL } from '@/lib/local-db.js';
 import logger from '@/lib/logger';
+import { parseSQLError } from '@/lib/parse-sql-error';
 import { sanitizeTableName, sanitizeColumnName } from '@/lib/sql-sanitizer.js';
 
 const execAsync = promisify(exec);
@@ -17,27 +19,30 @@ export const dynamic = 'force-dynamic';
 let isProcessing = false;
 
 /**
- * Executes a D1 SQL query using Wrangler.
- * This function ensures that only one query is processed at a time.
+ * Executes a D1 SQL query, preferring direct SQLite access over the wrangler CLI.
  */
-async function executeD1Query(command, projectDir, databaseName) {
+async function executeD1Query(sql, projectDir, dbConfig) {
+  // Try direct SQLite access first (fast path)
+  const localOutput = executeLocalSQL(projectDir, dbConfig, sql);
+  if (localOutput !== null) {
+    const parsed = JSON.parse(localOutput);
+    return parsed[0]?.results || [];
+  }
+
+  // Fall back to wrangler CLI
+  const databaseName = dbConfig.database_name;
   try {
-    // Wait until any current query is finished.
     while (isProcessing) {
       await new Promise(resolve => setTimeout(resolve, 100));
     }
     isProcessing = true;
-    
-    // Escape double quotes in the command and execute the query
     const { stdout } = await execAsync(
-      `wrangler d1 execute ${databaseName} --local --command="${command.replace(/"/g, '\\"')}" --json`,
+      `wrangler d1 execute ${databaseName} --local --command="${sql.replace(/"/g, '\\"')}" --json`,
       { cwd: projectDir }
     );
-    
     const result = JSON.parse(stdout);
     return result[0]?.results || [];
   } catch (error) {
-    logger.error('Query execution error:', error);
     throw error;
   } finally {
     isProcessing = false;
@@ -81,6 +86,8 @@ export async function GET(request, context) {
       const page = parseInt(searchParams.get('page')) || 1;
       const limit = parseInt(searchParams.get('limit')) || 50;
       const offset = (page - 1) * limit;
+      const isExport = searchParams.get('export') === 'true';
+      const dbParam = searchParams.get('db');
 
       const projectDir = process.env.D1_PROJECT_DIR;
       if (!projectDir) {
@@ -96,21 +103,23 @@ export async function GET(request, context) {
       if (!config.d1_databases?.length) {
         throw new Error('No D1 databases configured');
       }
-      // Get the first D1 database name from the configuration
-      const databaseName = config.d1_databases[0].database_name;
+      // Resolve target database — use ?db param if provided, else fall back to first
+      const dbConfig = dbParam
+        ? config.d1_databases.find(d => d.database_name === dbParam)
+        : config.d1_databases[0];
+      if (!dbConfig) throw new Error(`Database not found: ${dbParam}`);
+      const databaseName = dbConfig.database_name;
 
       // Validate and sanitize table name to prevent SQL injection
       const sanitizedTableName = sanitizeTableName(name);
       
       // Get table schema using PRAGMA query (PRAGMA is safe from injection when table name is sanitized)
       const schemaQuery = `PRAGMA table_info(${sanitizedTableName});`;
-      const schema = await executeD1Query(schemaQuery, projectDir, databaseName);
+      const schema = await executeD1Query(schemaQuery, projectDir, dbConfig);
 
-      // Get the CREATE TABLE statement from sqlite_master using parameterized query approach
-      const createTableQuery = `SELECT sql FROM sqlite_master WHERE type='table' AND name = ?;`;
-      // Note: executeD1Query would need to support parameters, for now we sanitize the table name
+      // Get the CREATE TABLE statement from sqlite_master
       const createTableQuerySafe = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${name.replace(/'/g, "''")}';`;
-      const tableDefinition = await executeD1Query(createTableQuerySafe, projectDir, databaseName);
+      const tableDefinition = await executeD1Query(createTableQuerySafe, projectDir, dbConfig);
       const createTableSQL = tableDefinition[0]?.sql || '';
 
       // Extract CHECK constraints from the CREATE TABLE statement
@@ -124,23 +133,25 @@ export async function GET(request, context) {
 
       // Get total row count for the table (using sanitized table name)
       const countQuery = `SELECT COUNT(*) as total FROM ${sanitizedTableName};`;
-      const countResult = await executeD1Query(countQuery, projectDir, databaseName);
+      const countResult = await executeD1Query(countQuery, projectDir, dbConfig);
       const totalRows = countResult[0]?.total || 0;
 
       // Fetch paginated data using the primary key column for ordering
       const primaryKeyColumn = schema.find(col => col.pk === 1)?.name || schema[0]?.name;
       const sanitizedPrimaryKey = primaryKeyColumn ? sanitizeColumnName(primaryKeyColumn) : '*';
-      
-      // Validate limit and offset to prevent injection through URL params
-      const safeLimitNum = Math.max(1, Math.min(parseInt(limit) || 50, 1000)); // Cap at 1000 rows
+
+      // For exports, skip the 1000-row cap; otherwise cap to prevent huge reads
+      const safeLimitNum = isExport
+        ? Math.max(1, parseInt(limit) || 99999)
+        : Math.max(1, Math.min(parseInt(limit) || 50, 1000));
       const safeOffsetNum = Math.max(0, parseInt(offset) || 0);
-      
+
       const dataQuery = `
-        SELECT * FROM ${sanitizedTableName} 
-        ORDER BY ${sanitizedPrimaryKey} DESC 
+        SELECT * FROM ${sanitizedTableName}
+        ORDER BY ${sanitizedPrimaryKey} DESC
         LIMIT ${safeLimitNum} OFFSET ${safeOffsetNum};
       `;
-      const data = await executeD1Query(dataQuery, projectDir, databaseName);
+      const data = await executeD1Query(dataQuery, projectDir, dbConfig);
 
       return NextResponse.json({
         success: true,
@@ -158,13 +169,11 @@ export async function GET(request, context) {
       });
 
     } catch (error) {
-      logger.error('Error handling request:', error);
+      const parsed = parseSQLError(error);
+      logger.error(`✗ ${parsed.message}`);
       return NextResponse.json({
         success: false,
-        error: {
-          message: error.message,
-          details: error.stack
-        }
+        error: { message: parsed.message }
       }, {
         status: error.message.includes('not configured') ? 500 :
                 error.message.includes('not found') ? 404 : 500

package/dist/app/api/tables/route.js

@@ -4,6 +4,7 @@ import { NextResponse } from 'next/server';
 import { promisify } from 'util';
 import { exec } from 'child_process';
 import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { executeLocalSQL } from '@/lib/local-db.js';
 import logger from '@/lib/logger';
 
 const execAsync = promisify(exec);
@@ -75,10 +76,13 @@ async function retryWithTimeout(fn, retries = 3, timeout = 1000) {
  * GET handler for listing tables.
  * It uses the Wrangler configuration (via findWranglerConfig) to determine the D1 database.
  */
-export async function GET() {
+export async function GET(request) {
   logger.logRequest('GET', '/api/tables');
 
   try {
+    const { searchParams } = new URL(request.url);
+    const dbParam = searchParams.get('db');
+
     const projectDir = process.env.D1_PROJECT_DIR;
 
     if (!projectDir) {
@@ -105,8 +109,14 @@ export async function GET() {
         { status: 404 }
       );
     }
-    // Get the first D1 database name from the configuration
-    const databaseName = config.d1_databases[0].database_name;
+    // Resolve target database — use ?db param if provided, else fall back to first
+    const dbConfig = dbParam
+      ? config.d1_databases.find(d => d.database_name === dbParam)
+      : config.d1_databases[0];
+    if (!dbConfig) {
+      return NextResponse.json({ error: `Database not found: ${dbParam}` }, { status: 404 });
+    }
+    const databaseName = dbConfig.database_name;
 
     // SQL query to list non-system tables
     const query = `
@@ -117,19 +127,22 @@ export async function GET() {
       ORDER BY name;
     `;
 
-    // Execute the query with a retry mechanism if the database is locked
-    const { stdout } = await retryWithTimeout(async () => {
-      return execAsync(
-        `wrangler d1 execute ${databaseName} --local --command="${query}"`,
-        { 
-          cwd: projectDir,
-          timeout: 5000 // 5 second timeout
-        }
-      );
-    });
-    
-    // Extract JSON from the command output and then extract table names
-    const result = extractJSONFromOutput(stdout);
+    // Try direct SQLite access first (fast), fall back to wrangler CLI
+    let result;
+    const localOutput = executeLocalSQL(projectDir, dbConfig, query.trim());
+    if (localOutput !== null) {
+      result = JSON.parse(localOutput);
+    } else {
+      const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+      const { stdout } = await retryWithTimeout(async () => {
+        return execAsync(
+          `${npxCmd} wrangler d1 execute ${databaseName} --local --json --command="${query.trim().replace(/\n\s*/g, ' ')}"`,
+          { cwd: projectDir, timeout: 10000 }
+        );
+      });
+      result = extractJSONFromOutput(stdout);
+    }
+
     const tables = extractTablesFromResult(result);
 
     return NextResponse.json({

package/dist/app/api/time-travel/preview/route.js

@@ -0,0 +1,122 @@
+// api/time-travel/preview/route.js
+// GET  → current bookmark + window info (no timestamp)
+// POST → bookmark for a specific timestamp
+
+import { NextResponse } from 'next/server';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import logger from '@/lib/logger';
+
+const execAsync = promisify(exec);
+
+async function resolveDb(req) {
+  const { searchParams } = new URL(req.url);
+  const db = searchParams.get('db');
+  const projectDir = process.env.D1_PROJECT_DIR;
+  if (!projectDir) throw Object.assign(new Error('Project directory not configured'), { status: 500 });
+
+  const wranglerResult = await findWranglerConfig(projectDir);
+  if (!wranglerResult?.config) throw Object.assign(new Error('No Wrangler configuration found'), { status: 400 });
+
+  const config = wranglerResult.config;
+  if (!config.d1_databases?.length) throw Object.assign(new Error('No D1 databases configured'), { status: 400 });
+
+  const dbConfig = db
+    ? config.d1_databases.find(d => d.database_name === db)
+    : config.d1_databases[0];
+  if (!dbConfig) throw Object.assign(new Error(`Database not found: ${db}`), { status: 404 });
+
+  return { projectDir, databaseName: dbConfig.database_name };
+}
+
+function parseBookmark(raw) {
+  const clean = (raw || '').replace(/\x1B\[[0-9;]*m/g, '');
+  const jsonStart = clean.indexOf('{');
+  const jsonEnd = clean.lastIndexOf('}');
+  if (jsonStart !== -1 && jsonEnd !== -1) {
+    try {
+      const parsed = JSON.parse(clean.slice(jsonStart, jsonEnd + 1));
+      return parsed.bookmark ?? parsed.result?.bookmark ?? null;
+    } catch { /* fall through */ }
+  }
+  const match = clean.match(/bookmark[:\s]+([0-9a-f-]+)/i);
+  return match ? match[1] : null;
+}
+
+/** GET /api/time-travel/preview?db=name  — returns current (latest) bookmark */
+export async function GET(req) {
+  if (process.env.D1_IS_PRO !== 'true') {
+    return NextResponse.json({ success: false, error: { type: 'PRO_REQUIRED', message: 'Pro license required. Run: d1s --license YOUR-KEY' } }, { status: 402 });
+  }
+  try {
+    const { projectDir, databaseName } = await resolveDb(req);
+    const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const command = `${npxCmd} wrangler d1 time-travel info ${databaseName} --json`;
+    logger.debug(`Time travel GET: ${command}`);
+
+    const { stdout } = await execAsync(command, {
+      cwd: projectDir, env: process.env,
+      maxBuffer: 1024 * 1024 * 4, shell: true,
+    });
+
+    const bookmark = parseBookmark(stdout);
+    return NextResponse.json({ success: true, currentBookmark: bookmark, databaseName });
+  } catch (error) {
+    const strip = s => (s || '').replace(/\x1B\[[0-9;]*m/g, '').trim();
+    const msg = strip(error.stderr) || strip(error.stdout) || strip(error.message) || 'Failed to get time travel info';
+    logger.error(`Time travel GET error: ${msg}`);
+    return NextResponse.json({ success: false, error: msg }, { status: error.status || 500 });
+  }
+}
+
+export async function POST(req) {
+  if (process.env.D1_IS_PRO !== 'true') {
+    return NextResponse.json({ success: false, error: { type: 'PRO_REQUIRED', message: 'Pro license required. Run: d1s --license YOUR-KEY' } }, { status: 402 });
+  }
+  try {
+    const body = await req.json();
+    const { timestamp } = body;
+    if (!timestamp) {
+      return NextResponse.json({ success: false, error: 'timestamp is required' }, { status: 400 });
+    }
+
+    // Re-use resolveDb but from body.db
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) return NextResponse.json({ success: false, error: 'Project directory not configured' }, { status: 500 });
+
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult?.config) return NextResponse.json({ success: false, error: 'No Wrangler configuration found' }, { status: 400 });
+
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) return NextResponse.json({ success: false, error: 'No D1 databases configured' }, { status: 400 });
+
+    const dbConfig = body.db
+      ? config.d1_databases.find(d => d.database_name === body.db)
+      : config.d1_databases[0];
+    if (!dbConfig) return NextResponse.json({ success: false, error: `Database not found: ${body.db}` }, { status: 404 });
+
+    const { database_name: databaseName } = dbConfig;
+    const unixTs = Math.floor(new Date(timestamp).getTime() / 1000);
+    const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const command = `${npxCmd} wrangler d1 time-travel info ${databaseName} --timestamp=${unixTs} --json`;
+    logger.debug(`Time travel POST: ${command}`);
+
+    const { stdout } = await execAsync(command, {
+      cwd: projectDir, env: process.env,
+      maxBuffer: 1024 * 1024 * 4, shell: true,
+    });
+
+    const bookmark = parseBookmark(stdout);
+    return NextResponse.json({ success: true, bookmark, databaseName });
+  } catch (error) {
+    const strip = s => (s || '').replace(/\x1B\[[0-9;]*m/g, '').trim();
+    const msg = strip(error.stderr) || strip(error.stdout) || strip(error.message) || 'Failed to get time travel info';
+    logger.error(`Time travel preview error: ${msg}`);
+    return NextResponse.json({ success: false, error: msg }, { status: 500 });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

package/dist/app/api/time-travel/restore/route.js

@@ -0,0 +1,106 @@
+// api/time-travel/restore/route.js
+// Calls `wrangler d1 time-travel restore` to roll back a remote D1 database.
+
+import { NextResponse } from 'next/server';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import logger from '@/lib/logger';
+
+const execAsync = promisify(exec);
+
+export async function POST(req) {
+  if (process.env.D1_IS_PRO !== 'true') {
+    return NextResponse.json({ success: false, error: { type: 'PRO_REQUIRED', message: 'Pro license required. Run: d1s --license YOUR-KEY' } }, { status: 402 });
+  }
+  try {
+    const { db, bookmark, timestamp } = await req.json();
+
+    if (!bookmark && !timestamp) {
+      return NextResponse.json(
+        { success: false, error: 'bookmark or timestamp is required' },
+        { status: 400 }
+      );
+    }
+
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) {
+      return NextResponse.json({ success: false, error: 'Project directory not configured' }, { status: 500 });
+    }
+
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult?.config) {
+      return NextResponse.json({ success: false, error: 'No Wrangler configuration found' }, { status: 400 });
+    }
+
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) {
+      return NextResponse.json({ success: false, error: 'No D1 databases configured' }, { status: 400 });
+    }
+
+    const dbConfig = db
+      ? config.d1_databases.find(d => d.database_name === db)
+      : config.d1_databases[0];
+
+    if (!dbConfig) {
+      return NextResponse.json({ success: false, error: `Database not found: ${db}` }, { status: 404 });
+    }
+
+    const databaseName = dbConfig.database_name;
+    const isWindows = process.platform === 'win32';
+    const npxCmd = isWindows ? 'npx.cmd' : 'npx';
+
+    // Prefer explicit bookmark; fall back to timestamp
+    let command;
+    if (bookmark) {
+      command = `${npxCmd} wrangler d1 time-travel restore ${databaseName} --bookmark=${bookmark} --json`;
+    } else {
+      const unixTs = Math.floor(new Date(timestamp).getTime() / 1000);
+      command = `${npxCmd} wrangler d1 time-travel restore ${databaseName} --timestamp=${unixTs} --json`;
+    }
+
+    logger.debug('Time travel restore command:', command);
+
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: projectDir,
+      env: process.env,
+      maxBuffer: 1024 * 1024 * 4,
+      shell: true,
+      timeout: 120000, // 2 min timeout for restore
+    });
+
+    const clean = stdout.replace(/\x1B\[[0-9;]*m/g, '');
+
+    // Try to extract undo bookmark from output
+    let undoBookmark = null;
+    const undoMatch = clean.match(/undo[^:]*bookmark[:\s]+([0-9a-f-]+)/i) ||
+                      clean.match(/pre.?restore[^:]*bookmark[:\s]+([0-9a-f-]+)/i) ||
+                      clean.match(/saved[^:]*bookmark[:\s]+([0-9a-f-]+)/i);
+    if (undoMatch) undoBookmark = undoMatch[1];
+
+    // Also try JSON parse
+    const jsonStart = clean.indexOf('{');
+    const jsonEnd = clean.lastIndexOf('}');
+    if (jsonStart !== -1 && jsonEnd !== -1) {
+      try {
+        const parsed = JSON.parse(clean.slice(jsonStart, jsonEnd + 1));
+        if (!undoBookmark) {
+          undoBookmark = parsed.undoBookmark ?? parsed.undo_bookmark ?? parsed.result?.undoBookmark ?? null;
+        }
+      } catch { /* ignore */ }
+    }
+
+    return NextResponse.json({ success: true, undoBookmark, databaseName });
+  } catch (error) {
+    const strip = s => (s || '').replace(/\x1B\[[0-9;]*m/g, '').trim();
+    const stderr = strip(error.stderr);
+    const stdout = strip(error.stdout);
+    const msg = stderr || stdout || strip(error.message) || 'Restore failed';
+    logger.error(`Time travel restore error: ${msg}`);
+    return NextResponse.json({ success: false, error: msg }, { status: 500 });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

package/dist/app/page.jsx

@@ -5,30 +5,48 @@ import { useState } from 'react';
 import { AppSidebar } from '../components/sidebar';
 import { SQLEditor } from '../components/sql-editor';
 import { TableView } from '../components/table-view';
+import { MigrationsView } from '../components/migrations-view';
+import { SchemaView } from '../components/schema-view';
+import { TimeTravelView } from '../components/time-travel-view';
+import { RemoteSyncView } from '../components/remote-sync-view';
+import { StatusBar } from '../components/status-bar';
 
 export default function StudioPage() {
   const [currentView, setCurrentView] = useState('sql-editor');
   const [selectedTable, setSelectedTable] = useState(null);
+  const [initialSqlQuery, setInitialSqlQuery] = useState('');
 
   const handleTableSelect = (tableName) => {
     setSelectedTable(tableName);
     setCurrentView('table-view');
   };
 
+  const handleOpenInSQL = (sql) => {
+    setInitialSqlQuery(sql);
+    setCurrentView('sql-editor');
+  };
+
   return (
     <div className="flex h-screen bg-background">
-      <AppSidebar 
-        className="w-64 border-r flex-shrink-0" 
+      <AppSidebar
+        className="w-64 border-r flex-shrink-0"
         currentView={currentView}
         onNavigate={setCurrentView}
         onTableSelect={handleTableSelect}
       />
-      <main className="flex-1 overflow-hidden">
-        {currentView === 'sql-editor' && <SQLEditor />}
-        {currentView === 'table-view' && selectedTable && (
-          <TableView tableName={selectedTable} />
-        )}
-      </main>
+      <div className="flex-1 flex flex-col overflow-hidden">
+        <main className="flex-1 overflow-hidden">
+          {currentView === 'sql-editor' && <SQLEditor initialQuery={initialSqlQuery} />}
+          {currentView === 'schema' && <SchemaView />}
+          {currentView === 'migrations' && <MigrationsView />}
+          {currentView === 'time-travel' && <TimeTravelView />}
+          {currentView === 'remote-sync' && <RemoteSyncView />}
+          {currentView === 'table-view' && selectedTable && (
+            <TableView tableName={selectedTable} onOpenInSQL={handleOpenInSQL} />
+          )}
+        </main>
+        <StatusBar />
+      </div>
     </div>
   );
 }