d1s 0.2.1

package/dist/app/api/push-remote/preview/route.js

@@ -0,0 +1,178 @@
+// api/push-remote/preview/route.js
+
+import { NextResponse } from 'next/server';
+import { readdir } from 'fs/promises';
+import path from 'path';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { executeSQL, ErrorTypes } from '@/lib/sql-operations';
+import { validateMigrationFile } from '@/lib/migrations.js';
+
+/**
+ * Pushes migration preview to remote.
+ * Validates migration files against remote migration records and returns a preview
+ * of which migrations will be applied, skipped, or failed.
+ *
+ * Note: For remote, we no longer use the checksum.
+ */
+async function pushToRemote(projectDir, accountId, apiToken, databaseName, preview = true) {
+  const env = {
+    ...process.env,
+    CLOUDFLARE_ACCOUNT_ID: accountId,
+    CLOUDFLARE_API_TOKEN: apiToken,
+  };
+
+  try {
+    // Create local migrations table (with checksum)
+    const localCreateMigrationsTable = `
+      CREATE TABLE IF NOT EXISTS d1_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        checksum TEXT NOT NULL,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+    // Create remote migrations table (without checksum; use applied_at)
+    const remoteCreateMigrationsTable = `
+      CREATE TABLE IF NOT EXISTS d1_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+    await executeSQL(projectDir, databaseName, localCreateMigrationsTable);
+    await executeSQL(projectDir, databaseName, remoteCreateMigrationsTable, env, true);
+
+    // Get remote migration records using applied_at for ordering.
+    const remoteMigrations = await executeSQL(
+      projectDir,
+      databaseName,
+      'SELECT name FROM d1_migrations ORDER BY applied_at;',
+      env,
+      true
+    );
+    const parseResults = (stdout) => {
+      try {
+        const parsed = JSON.parse(stdout);
+        return parsed[0]?.results || [];
+      } catch {
+        return [];
+      }
+    };
+    // Use migration file name as key
+    const remoteMigrationsMap = new Map(
+      parseResults(remoteMigrations).map(m => [m.name, m])
+    );
+
+    // Read migration files from disk.
+    const migrationsDir = path.join(projectDir, 'migrations');
+    const files = await readdir(migrationsDir);
+    const migrationFiles = files.filter(f => f.endsWith('.sql')).sort();
+
+    const results = { applied: [], skipped: [], preview: [] };
+
+    // Process each migration file.
+    for (const migrationFile of migrationFiles) {
+      const fullPath = path.join(migrationsDir, migrationFile);
+      const previewRecord = { name: migrationFile, action: '', reason: '' };
+      try {
+        const validation = await validateMigrationFile(fullPath);
+        if (!validation.isValid) {
+          previewRecord.action = 'failed validation';
+          previewRecord.reason = 'Migration validation failed';
+          results.preview.push(previewRecord);
+          continue;
+        }
+        // For push preview, compare by migration file name.
+        if (remoteMigrationsMap.has(migrationFile)) {
+          previewRecord.action = 'skipped';
+          previewRecord.reason = 'Already applied';
+          results.preview.push(previewRecord);
+          results.skipped.push({ name: migrationFile, reason: previewRecord.reason });
+          continue;
+        }
+        previewRecord.action = 'will be applied';
+        results.preview.push(previewRecord);
+      } catch (error) {
+        previewRecord.action = 'failed';
+        previewRecord.reason = error.message || 'Failed to process migration';
+        results.preview.push(previewRecord);
+        results.skipped.push({ name: migrationFile, reason: previewRecord.reason });
+      }
+    }
+
+    console.log("Push Preview Result (server):", results);
+    return { success: true, preview: true, applied: results.applied.length, skipped: results.skipped.length, details: results };
+  } catch (error) {
+    throw {
+      type: ErrorTypes.EXECUTION_ERROR,
+      message: error.message || 'Failed to push migrations',
+      details: error.details || { error: error.stderr || error.message }
+    };
+  }
+}
+
+/**
+ * POST handler for push-remote preview.
+ * Loads the Wrangler configuration to obtain the D1 database name,
+ * then calls pushToRemote in preview mode and returns a preview.
+ */
+export async function POST(req) {
+  try {
+    const { accountId, apiToken } = await req.json();
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) {
+      return NextResponse.json({
+        success: false,
+        error: {
+          type: ErrorTypes.VALIDATION_ERROR,
+          message: 'Project directory not configured'
+        }
+      }, { status: 500 });
+    }
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult || !wranglerResult.config) {
+      return NextResponse.json({
+        success: false,
+        error: {
+          type: ErrorTypes.VALIDATION_ERROR,
+          message: 'Could not find Wrangler configuration'
+        }
+      }, { status: 400 });
+    }
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) {
+      return NextResponse.json({
+        success: false,
+        error: {
+          type: ErrorTypes.VALIDATION_ERROR,
+          message: 'No D1 databases configured'
+        }
+      }, { status: 400 });
+    }
+    const databaseName = config.d1_databases[0].database_name;
+    const result = await pushToRemote(projectDir, accountId, apiToken, databaseName, true);
+    return NextResponse.json({
+      success: true,
+      message: 'Preview generated for migrations to be pushed to remote',
+      details: result
+    });
+  } catch (error) {
+    console.error('Push to remote preview error:', error);
+    return NextResponse.json({
+      success: false,
+      error: {
+        type: error.type || ErrorTypes.EXECUTION_ERROR,
+        message: error.message || 'Failed to push to remote preview',
+        details: error.details || { error: error.stderr || error.message }
+      }
+    }, { status: error.type === ErrorTypes.VALIDATION_ERROR ? 400 : 500 });
+  }
+}
+
+/**
+ * OPTIONS handler for pre-flight requests.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}
+

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

@@ -0,0 +1,160 @@
+// api/query/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { 
+  ErrorTypes,
+  parseQuery,
+  executeSQL,
+  validateStatement  
+} from '@/lib/sql-operations';
+import { handleSchemaChange } from '@/lib/migrations';
+import { isSchemaChange } from '@/lib/sql-operations';
+import { parseSQLError } from '@/lib/parse-sql-error';
+
+/**
+ * API POST handler to execute SQL queries against the configured D1 database.
+ */
+export async function POST(req) {
+  try {
+    // Ensure that the project directory is set.
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) {
+      return NextResponse.json(
+        { error: 'Project directory not configured' },
+        { status: 500 }
+      );
+    }
+
+    // Extract the SQL query from the request body.
+    const { query } = await req.json();
+    console.log('Received query:', query);
+
+    if (!query?.trim()) {
+      return NextResponse.json(
+        { success: false, error: { message: 'Query cannot be empty' } },
+        { status: 400 }
+      );
+    }
+
+    // Retrieve the Wrangler configuration using the centralized helper.
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult || !wranglerResult.config) {
+      return NextResponse.json(
+        { success: false, error: { message: 'No Wrangler configuration file found' } },
+        { status: 404 }
+      );
+    }
+    const config = wranglerResult.config;
+
+    // Check if there is at least one D1 database configured.
+    if (!config.d1_databases?.length) {
+      return NextResponse.json(
+        { success: false, error: { message: 'No D1 databases configured' } },
+        { status: 404 }
+      );
+    }
+
+    // Use the first configured database.
+    const databaseName = config.d1_databases[0].database_name;
+    console.log('Using database:', databaseName);
+
+    // Parse the query into individual SQL statements.
+    let statements = parseQuery(query);
+    console.log('Parsed statements:', statements);
+
+    if (!statements.length) {
+      return NextResponse.json(
+        { success: false, error: { message: 'No valid SQL statements found' } },
+        { status: 400 }
+      );
+    }
+
+    // Validate each parsed statement.
+    statements = statements.map(validateStatement);
+    console.log('Validated statements:', statements);
+
+    // Initialize the migrations table (if it doesn't already exist).
+    const createMigrationsTable = `
+      CREATE TABLE IF NOT EXISTS d1_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        checksum TEXT NOT NULL,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+    await executeSQL(projectDir, databaseName, createMigrationsTable);
+
+    // Determine whether the query involves any schema changes.
+    const hasSchemaChanges = statements.some(isSchemaChange);
+    console.log('Has schema changes:', hasSchemaChanges);
+
+    let result;
+    if (hasSchemaChanges) {
+      // Process schema changes and capture migrations.
+      // The handleSchemaChange helper is responsible for executing the DDL statements.
+      const migrations = await handleSchemaChange(projectDir, databaseName, statements);
+      console.log('Schema changes processed:', migrations);
+      
+      result = {
+        success: true,
+        migrations,
+        results: [{ results: [] }]
+      };
+    } else {
+      // For data modification queries, execute the statements.
+      const results = [];
+      for (const stmt of statements) {
+        console.log('Executing data modification:', stmt.sql);
+        const output = await executeSQL(projectDir, databaseName, stmt.sql);
+        
+        try {
+          const parsed = JSON.parse(output);
+          const queryResults = parsed[0]?.results || [];
+          results.push(...queryResults);
+        } catch (parseError) {
+          console.log('Non-JSON output:', output);
+          continue;
+        }
+      }
+
+      result = {
+        success: true,
+        results: [{ results }]
+      };
+    }
+
+    return NextResponse.json(result);
+
+  } catch (error) {
+    console.error('Query execution error:', error);
+    const parsedError = parseSQLError(error);
+    
+    const statusCode = 
+      error.type === ErrorTypes.VALIDATION_ERROR ? 400 :
+      error.type === ErrorTypes.DEPENDENCY_ERROR ? 409 :
+      500;
+
+    return NextResponse.json(
+      { 
+        success: false, 
+        error: parsedError 
+      }, 
+      { status: statusCode }
+    );
+  }
+}
+
+/**
+ * OPTIONS handler for pre-flight requests.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type'
+    }
+  });
+}

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

@@ -0,0 +1,173 @@
+// app/api/tables/[name]/route.js
+
+import { NextResponse } from 'next/server';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { dbQueue } from '@/lib/database-queue';
+
+const execAsync = promisify(exec);
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+// Global query queue to prevent database locks
+let isProcessing = false;
+
+/**
+ * Executes a D1 SQL query using Wrangler.
+ * This function ensures that only one query is processed at a time.
+ */
+async function executeD1Query(command, projectDir, databaseName) {
+  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`,
+      { cwd: projectDir }
+    );
+    
+    const result = JSON.parse(stdout);
+    return result[0]?.results || [];
+  } catch (error) {
+    console.error('Query execution error:', error);
+    throw error;
+  } finally {
+    isProcessing = false;
+  }
+}
+
+/**
+ * Extracts CHECK constraints from a CREATE TABLE SQL statement.
+ */
+function extractCheckConstraints(createTableSQL) {
+  const checkConstraints = {};
+  const checkRegex = /CHECK\s*\(\s*(\w+)\s+IN\s*\((.*?)\)\s*\)/gi;
+  let match;
+
+  while ((match = checkRegex.exec(createTableSQL)) !== null) {
+    const columnName = match[1];
+    const values = match[2]
+      .split(',')
+      .map(value => value.trim().replace(/^'|'$/g, ''));
+    
+    checkConstraints[columnName] = values;
+  }
+
+  return checkConstraints;
+}
+
+/**
+ * GET handler for fetching table details, schema, and data.
+ * It retrieves the Wrangler configuration using the helper and uses that
+ * to determine the target D1 database.
+ */
+export async function GET(request, context) {
+  return dbQueue.add(async () => {
+    try {
+      // Extract table name from route parameters
+      const params = await context.params;
+      const { name } = params;
+      
+      // Get pagination info from the query parameters
+      const { searchParams } = new URL(request.url);
+      const page = parseInt(searchParams.get('page')) || 1;
+      const limit = parseInt(searchParams.get('limit')) || 50;
+      const offset = (page - 1) * limit;
+
+      const projectDir = process.env.D1_PROJECT_DIR;
+      if (!projectDir) {
+        throw new Error('Project directory not configured');
+      }
+
+      // Use the centralized helper to find Wrangler configuration
+      const wranglerResult = await findWranglerConfig(projectDir);
+      if (!wranglerResult || !wranglerResult.config) {
+        throw new Error('No Wrangler configuration file found');
+      }
+      const config = wranglerResult.config;
+      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;
+
+      // Get table schema using PRAGMA query
+      const schemaQuery = `PRAGMA table_info(${name});`;
+      const schema = await executeD1Query(schemaQuery, projectDir, databaseName);
+
+      // Get the CREATE TABLE statement from sqlite_master
+      const createTableQuery = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${name}';`;
+      const tableDefinition = await executeD1Query(createTableQuery, projectDir, databaseName);
+      const createTableSQL = tableDefinition[0]?.sql || '';
+
+      // Extract CHECK constraints from the CREATE TABLE statement
+      const checkConstraints = extractCheckConstraints(createTableSQL);
+
+      // Merge constraints into the schema response
+      const enhancedSchema = schema.map(column => ({
+        ...column,
+        check: checkConstraints[column.name] || null
+      }));
+
+      // Get total row count for the table
+      const countQuery = `SELECT COUNT(*) as total FROM ${name};`;
+      const countResult = await executeD1Query(countQuery, projectDir, databaseName);
+      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 dataQuery = `
+        SELECT * FROM ${name} 
+        ORDER BY ${primaryKeyColumn} DESC 
+        LIMIT ${limit} OFFSET ${offset};
+      `;
+      const data = await executeD1Query(dataQuery, projectDir, databaseName);
+
+      return NextResponse.json({
+        success: true,
+        schema: enhancedSchema,
+        data,
+        meta: {
+          tableName: name,
+          total: totalRows,
+          page,
+          limit,
+          totalPages: Math.ceil(totalRows / limit),
+          rowCount: data.length,
+          columnCount: schema.length
+        }
+      });
+
+    } catch (error) {
+      console.error('Error handling request:', error);
+      return NextResponse.json({
+        success: false,
+        error: {
+          message: error.message,
+          details: error.stack
+        }
+      }, {
+        status: error.message.includes('not configured') ? 500 :
+                error.message.includes('not found') ? 404 : 500
+      });
+    }
+  }); 
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    },
+  });
+}
+

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

@@ -0,0 +1,174 @@
+// app/api/tables/route.js
+
+import { NextResponse } from 'next/server';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Attempts to extract a JSON object from a string.
+ * First, it tries to parse the entire string.
+ * If that fails, it searches for a JSON portion within the string.
+ */
+function extractJSONFromOutput(stdout) {
+  try {
+    // First try to parse the entire output as JSON
+    return JSON.parse(stdout);
+  } catch (e) {
+    // If that fails, try to find and parse just the JSON portion
+    const jsonStart = stdout.indexOf('[') !== -1 ? 
+                     stdout.indexOf('[') : 
+                     stdout.indexOf('{');
+    
+    if (jsonStart === -1) return null;
+    
+    try {
+      const jsonStr = stdout.substring(jsonStart);
+      return JSON.parse(jsonStr);
+    } catch (error) {
+      console.error('Error parsing JSON portion:', error);
+      return null;
+    }
+  }
+}
+
+/**
+ * Extracts table names from the query result.
+ */
+function extractTablesFromResult(result) {
+  if (!result) return [];
+  
+  if (Array.isArray(result) && result[0]?.results) {
+    return result[0].results.map(row => row.name);
+  }
+  
+  if (result.results?.[0]?.results) {
+    return result.results[0].results.map(row => row.name);
+  }
+  
+  return [];
+}
+
+/**
+ * Retries a function if it fails with a timeout (e.g. due to a locked database).
+ */
+async function retryWithTimeout(fn, retries = 3, timeout = 1000) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === retries - 1) throw error;
+      if (error.message.includes('database is locked')) {
+        console.log(`Database locked, retrying in ${timeout}ms... (attempt ${i + 1}/${retries})`);
+        await new Promise(resolve => setTimeout(resolve, timeout));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+/**
+ * GET handler for listing tables.
+ * It uses the Wrangler configuration (via findWranglerConfig) to determine the D1 database.
+ */
+export async function GET() {
+  try {
+    const projectDir = process.env.D1_PROJECT_DIR;
+
+    if (!projectDir) {
+      console.error('D1_PROJECT_DIR environment variable is not set');
+      return NextResponse.json(
+        { error: 'Project directory not configured' },
+        { status: 500 }
+      );
+    }
+
+    // Use the centralized helper to get Wrangler configuration
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult || !wranglerResult.config) {
+      return NextResponse.json(
+        { error: 'No Wrangler configuration file found in project directory' },
+        { status: 404 }
+      );
+    }
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) {
+      return NextResponse.json(
+        { error: 'No D1 databases configured in Wrangler configuration' },
+        { status: 404 }
+      );
+    }
+    // Get the first D1 database name from the configuration
+    const databaseName = config.d1_databases[0].database_name;
+
+    // SQL query to list non-system tables
+    const query = `
+      SELECT name FROM sqlite_master 
+      WHERE type='table' 
+      AND name NOT LIKE 'sqlite_%'
+      AND name NOT LIKE '_cf_%'
+      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);
+    const tables = extractTablesFromResult(result);
+
+    return NextResponse.json({
+      success: true,
+      tables,
+      debug: {
+        projectDir,
+        tableCount: tables.length
+      }
+    });
+
+  } catch (error) {
+    console.error('Error fetching tables:', error);
+    
+    // Enhanced error response for troubleshooting
+    const errorResponse = {
+      error: 'Failed to fetch tables',
+      details: error.message,
+      debug: {
+        errorCode: error.code,
+        errorStack: error.stack,
+      }
+    };
+
+    // Check for specific error types (e.g., database locked)
+    if (error.message.includes('database is locked')) {
+      errorResponse.error = 'Database is temporarily locked';
+      errorResponse.retryAfter = 1000; // Suggest retry after 1 second
+    }
+
+    return NextResponse.json(errorResponse, { 
+      status: error.message.includes('database is locked') ? 503 : 500 
+    });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    },
+  });
+}