d1s 0.2.10 → 0.2.12

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

@@ -1,179 +0,0 @@
-// 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';
-import logger from '@/lib/logger';
-
-/**
- * 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 });
-      }
-    }
-
-    logger.debug("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) {
-    logger.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/src/app/api/query/route.js

@@ -1,168 +0,0 @@
-// 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';
-import logger from '@/lib/logger';
-
-/**
- * API POST handler to execute SQL queries against the configured D1 database.
- */
-export async function POST(req) {
-  logger.logRequest('POST', '/api/query');
-
-  try {
-    // Ensure that the project directory is set.
-    const projectDir = process.env.D1_PROJECT_DIR;
-    if (!projectDir) {
-      logger.error('Project directory not configured');
-      return NextResponse.json(
-        { error: 'Project directory not configured' },
-        { status: 500 }
-      );
-    }
-
-    // Extract the SQL query from the request body.
-    const { query } = await req.json();
-
-    if (logger.shouldLog('debug')) {
-      logger.debug('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) {
-      logger.error('No Wrangler configuration file found');
-      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) {
-    logger.logError(error, 'query-route');
-    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/src/app/api/tables/[name]/route.js

@@ -1,174 +0,0 @@
-// 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';
-import logger from '@/lib/logger';
-
-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) {
-    logger.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) {
-      logger.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/src/app/api/tables/route.js

@@ -1,178 +0,0 @@
-// 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';
-import logger from '@/lib/logger';
-
-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() {
-  logger.logRequest('GET', '/api/tables');
-
-  try {
-    const projectDir = process.env.D1_PROJECT_DIR;
-
-    if (!projectDir) {
-      logger.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) {
-      logger.error('No Wrangler configuration file found');
-      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) {
-    logger.logError(error, 'tables-route');
-    
-    // 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',
-    },
-  });
-}