d1s 0.2.1

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

@@ -0,0 +1,143 @@
+// api/pull-remote/preview/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { ErrorTypes,} from '@/lib/sql-operations';
+import { getCurrentSchema, analyzeDependencies } from '@/lib/schema-operations';
+import { getRemoteMigrations } from '@/lib/migrations.js';
+
+/**
+ * Generates a preview for pulling remote migrations.
+ * Retrieves the remote schema and migration metadata, orders tables by dependency,
+ * and builds a preview object that lists which tables will be created and which migrations will be tracked.
+ *
+ * @param {string} projectDir - The project directory path.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ * @param {string} databaseName - The target D1 database name.
+ * @returns {object} Preview object containing migration details.
+ */
+async function generatePullPreview(projectDir, accountId, apiToken, databaseName) {
+  const env = {
+    ...process.env,
+    CLOUDFLARE_API_TOKEN: apiToken,
+    CLOUDFLARE_ACCOUNT_ID: accountId
+  };
+
+  try {
+    // Get the remote schema and migration metadata using provided helpers
+    const remoteSchema = await getCurrentSchema(projectDir, databaseName, env, true);
+    const remoteMigrations = await getRemoteMigrations(projectDir, databaseName, env);
+    
+    // Analyze dependencies to order tables for creation
+    const orderedTables = analyzeDependencies(remoteSchema);
+
+    // Build the preview object
+    const preview = {
+      preview: [],
+      totalTables: remoteSchema.length,
+      totalMigrations: remoteMigrations.length
+    };
+
+    // Add each table (ordered by dependency) to the preview list
+    orderedTables.forEach((tableName, index) => {
+      const table = remoteSchema.find(t => t.name === tableName);
+      if (table) {
+        preview.preview.push({
+          name: tableName,
+          type: 'table',
+          action: 'will be created',
+          order: index + 1
+        });
+      }
+    });
+
+    // Add migration records to the preview.
+    // Since remote migrations do not include a checksum, we omit it.
+    remoteMigrations.forEach(migration => {
+      preview.preview.push({
+        name: migration.name,
+        type: 'migration',
+        action: 'will be tracked'
+      });
+    });
+
+    return preview;
+  } catch (error) {
+    console.error('Pull preview generation error:', error);
+    throw error;
+  }
+}
+
+/**
+ * POST handler for pull-remote preview.
+ * Reads the Wrangler configuration (via findWranglerConfig) to get the D1 database name,
+ * then generates a preview of the migrations to be pulled.
+ */
+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 });
+    }
+
+    // Load Wrangler configuration.
+    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;
+
+    // Ensure that at least one D1 database is configured.
+    if (!config.d1_databases?.length) {
+      return NextResponse.json({
+        success: false,
+        error: { 
+          type: ErrorTypes.VALIDATION_ERROR, 
+          message: 'No D1 databases configured'
+        }
+      }, { status: 400 });
+    }
+
+    // Use the first D1 database's name from the configuration.
+    const databaseName = config.d1_databases[0].database_name;
+    const preview = await generatePullPreview(projectDir, accountId, apiToken, databaseName);
+
+    return NextResponse.json({
+      success: true,
+      message: 'Pull migration preview generated',
+      details: preview
+    });
+  } catch (error) {
+    console.error('Pull remote preview error:', error);
+    return NextResponse.json({
+      success: false,
+      error: {
+        type: error.type || ErrorTypes.EXECUTION_ERROR,
+        message: error.message || 'Failed to generate pull migration preview',
+        details: error.details
+      }
+    }, { status: 500 });
+  }
+}
+
+/**
+ * OPTIONS handler for pre-flight requests.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

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

@@ -0,0 +1,196 @@
+// api/push-remote/confirm/route.js
+
+import { NextResponse } from 'next/server';
+import { readFile, readdir } from 'fs/promises';
+import path from 'path';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { executeSQL, ErrorTypes, tableExists, parseStatement, removeSQLComments } from '@/lib/sql-operations';
+import { validateMigrationFile } from '@/lib/migrations.js';
+
+async function pushToRemote(projectDir, accountId, apiToken, databaseName, preview = false) {
+  const env = {
+    ...process.env,
+    CLOUDFLARE_ACCOUNT_ID: accountId,
+    CLOUDFLARE_API_TOKEN: apiToken,
+  };
+
+  try {
+    // Create local migrations table (with checksum) and remote migrations table (without 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
+      );
+    `;
+    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.
+    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 [];
+      }
+    };
+    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 remote, 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;
+    }
+    // Read the migration content.
+    let content = await readFile(fullPath, 'utf8');
+    // Strip out any header comments (lines starting with "--").
+    content = removeSQLComments(content);
+    // Parse the SQL content to extract details.
+    const parsedStatement = parseStatement(content);
+    const tableName = parsedStatement.tableName;
+    
+    // Only if the migration is a CREATE_TABLE do we check for existing table.
+    if (parsedStatement.type === 'CREATE_TABLE' && tableName) {
+      const exists = await tableExists(projectDir, databaseName, env, tableName, true);
+      if (exists) {
+        previewRecord.action = 'skipped';
+        previewRecord.reason = `Table "${tableName}" already exists`;
+        results.skipped.push({ name: migrationFile, reason: previewRecord.reason });
+        results.preview.push(previewRecord);
+        continue;
+      }
+    }
+    // For ALTER_TABLE and other migrations, we do not skip based on table existence.
+    previewRecord.action = 'will be applied';
+    results.preview.push(previewRecord);
+    if (!preview) {
+      // Execute the migration SQL on the remote database.
+      await executeSQL(projectDir, databaseName, content, env, true);
+      // Record the migration on remote (without checksum).
+      await executeSQL(
+        projectDir,
+        databaseName,
+        `INSERT INTO d1_migrations (name) VALUES ('${migrationFile}');`,
+        env,
+        true
+      );
+      previewRecord.action = 'applied';
+      results.applied.push({ name: migrationFile });
+    }
+      } catch (err) {
+        // If error indicates the object already exists, mark as skipped.
+        const errMsg = err.message || '';
+        const errStderr = (err.details && err.details.stderr) || '';
+        if (errMsg.includes("already exists") || errStderr.includes("already exists")) {
+          previewRecord.action = 'skipped';
+          previewRecord.reason = 'Already applied';
+          results.skipped.push({ name: migrationFile, reason: previewRecord.reason });
+        } else {
+          previewRecord.action = 'failed';
+          previewRecord.reason = errMsg || 'Failed to apply migration';
+          results.skipped.push({ name: migrationFile, reason: previewRecord.reason });
+        }
+        results.preview.push(previewRecord);
+      }
+    }
+    console.log("Push Confirm Result (server):", results);
+    return { success: true, preview: false, 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 }
+    };
+  }
+}
+
+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: { message: 'Project directory not configured', type: ErrorTypes.VALIDATION_ERROR }
+      }, { status: 500 });
+    }
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult || !wranglerResult.config) {
+      return NextResponse.json({
+        success: false,
+        error: { message: 'Could not find Wrangler configuration', type: ErrorTypes.VALIDATION_ERROR }
+      }, { status: 400 });
+    }
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) {
+      return NextResponse.json({
+        success: false,
+        error: { message: 'No D1 databases configured', type: ErrorTypes.VALIDATION_ERROR }
+      }, { status: 400 });
+    }
+    const databaseName = config.d1_databases[0].database_name;
+    // Force preview to be false for actual execution.
+    const result = await pushToRemote(projectDir, accountId, apiToken, databaseName, false);
+    return NextResponse.json({
+      success: true,
+      message: 'Successfully pushed migrations to remote',
+      details: result
+    });
+  } catch (error) {
+    console.error('Push to remote confirm error:', error);
+    return NextResponse.json({
+      success: false,
+      error: {
+        type: error.type || ErrorTypes.EXECUTION_ERROR,
+        message: error.message || 'Failed to push to remote',
+        details: error.details || { error: error.stderr || error.message }
+      }
+    }, { status: error.type === ErrorTypes.VALIDATION_ERROR ? 400 : 500 });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}
+
+

package/src/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/src/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'
+    }
+  });
+}