d1s 0.2.1

package/src/app/api/databases/route.js

@@ -0,0 +1,72 @@
+// api/databases/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+
+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 }
+      );
+    }
+
+    console.log('Looking for Wrangler configuration in:', projectDir);
+    
+    // Use findWranglerConfig helper
+    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 }
+      );
+    }
+
+    return NextResponse.json({
+      databases: config.d1_databases,
+      debug: {
+        projectDir,
+        // Exposing the path from the helper for debugging consistency
+        configPath: wranglerResult.configPath || 'N/A',
+        databaseCount: config.d1_databases.length
+      }
+    });
+  } catch (error) {
+    console.error('Error reading database configuration:', error);
+    
+    return NextResponse.json(
+      { 
+        error: 'Failed to read database configuration',
+        details: error.message,
+        debug: {
+          errorCode: error.code,
+          errorStack: error.stack
+        }
+      },
+      { status: 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/migrations/sync/route.js

@@ -0,0 +1,172 @@
+// app/api/migrations/sync/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import {
+  initMigrationsTable,
+  compareMigrations,
+  trackMigration,
+  updateMigrationStatus,
+  createChecksum
+} from '@/lib/migrations';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+
+const execAsync = promisify(exec);
+
+/**
+ * POST handler for syncing migrations.
+ * Uses the centralized Wrangler configuration helper to determine the D1 database.
+ */
+export async function POST(req) {
+  try {
+    const { accountId, apiToken } = await req.json();
+    const projectDir = process.env.D1_PROJECT_DIR;
+
+    if (!projectDir) {
+      return NextResponse.json(
+        { error: 'Project directory not configured' },
+        { status: 500 }
+      );
+    }
+
+    // Use the helper to load the 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' },
+        { status: 404 }
+      );
+    }
+    const databaseName = config.d1_databases[0].database_name;
+
+    // Initialize remote first (simpler schema)
+    await execAsync(
+      `wrangler d1 execute ${databaseName} --remote --command="
+        CREATE TABLE IF NOT EXISTS d1_migrations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL UNIQUE,
+          applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );"`,
+      {
+        env: {
+          ...process.env,
+          CLOUDFLARE_ACCOUNT_ID: accountId,
+          CLOUDFLARE_API_TOKEN: apiToken
+        },
+        cwd: projectDir
+      }
+    );
+
+    // For local, explicitly create with nullable checksum
+    await execAsync(
+      `wrangler d1 execute ${databaseName} --local --command="
+        CREATE TABLE IF NOT EXISTS d1_migrations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL UNIQUE,
+          checksum TEXT DEFAULT NULL,
+          applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );"`,
+      { cwd: projectDir }
+    );
+
+    // Compare migrations between environments
+    const comparison = await compareMigrations(projectDir, databaseName);
+
+    // Handle pending migrations
+    const results = {
+      applied: [],
+      failed: [],
+      skipped: []
+    };
+
+    for (const migration of comparison.pending) {
+      try {
+        // Read migration file content
+        const migrationPath = path.join(projectDir, 'migrations', migration.name);
+        const migrationContent = await readFile(migrationPath, 'utf8');
+
+        // Execute migration in remote environment using Wrangler
+        const process = await execAsync(
+          `wrangler d1 execute ${databaseName} --remote --command='${migrationContent.replace(/'/g, "''")}'`,
+          {
+            env: {
+              ...process.env,
+              CLOUDFLARE_ACCOUNT_ID: accountId,
+              CLOUDFLARE_API_TOKEN: apiToken
+            },
+            cwd: projectDir
+          }
+        );
+
+        // Track successful migration in the remote environment
+        await trackMigration(projectDir, databaseName, {
+          name: migration.name,
+          environment: 'remote',
+          status: 'applied',
+          checksum: createChecksum(migrationContent),
+          version: migration.version
+        });
+
+        results.applied.push(migration.name);
+
+      } catch (error) {
+        console.error(`Failed to apply migration ${migration.name}:`, error);
+
+        // Track failed migration
+        await trackMigration(projectDir, databaseName, {
+          name: migration.name,
+          environment: 'remote',
+          status: 'failed',
+          checksum: migration.checksum,
+          version: migration.version,
+          errorMessage: error.message
+        });
+
+        results.failed.push({
+          name: migration.name,
+          error: error.message
+        });
+      }
+    }
+
+    // Handle migration conflicts (e.g., checksum mismatches)
+    for (const conflict of comparison.conflicts) {
+      results.skipped.push({
+        name: conflict.name,
+        reason: 'Checksum mismatch between environments'
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      results: {
+        ...results,
+        synced: comparison.synced
+      }
+    });
+
+  } catch (error) {
+    console.error('Migration sync error:', error);
+    return NextResponse.json({
+      success: false,
+      error: {
+        message: 'Failed to sync migrations',
+        details: error.message
+      }
+    }, { status: 500 });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

package/src/app/api/migrations/sync-files/route.js

@@ -0,0 +1,172 @@
+// app/api/migrations/sync-files/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { readFile, readdir } from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { createChecksum } from '@/lib/migrations';
+
+const execAsync = promisify(exec);
+
+/**
+ * Retrieves the list of migrations recorded in the D1 migrations table.
+ */
+async function getDatabaseMigrations(projectDir, databaseName) {
+  try {
+    const { stdout } = await execAsync(
+      `wrangler d1 execute ${databaseName} --local --command="SELECT name, checksum FROM d1_migrations;" --json`,
+      { cwd: projectDir }
+    );
+
+    const result = JSON.parse(stdout);
+    return result.results?.[0]?.results || [];
+  } catch (error) {
+    console.error('Error getting database migrations:', error);
+    throw new Error('Failed to get database migrations');
+  }
+}
+
+/**
+ * Reads migration files from the local migrations directory.
+ */
+async function getMigrationFiles(projectDir) {
+  try {
+    const migrationsDir = path.join(projectDir, 'migrations');
+    const files = await readdir(migrationsDir);
+    
+    const migrations = await Promise.all(
+      files
+        .filter(f => f.endsWith('.sql'))
+        .map(async name => {
+          const filePath = path.join(migrationsDir, name);
+          const content = await readFile(filePath, 'utf8');
+          return {
+            name,
+            path: filePath,
+            content,
+            checksum: createChecksum(content)
+          };
+        })
+    );
+
+    return migrations.sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return [];
+    }
+    throw new Error('Failed to read migration files');
+  }
+}
+
+/**
+ * Executes a database query via Wrangler.
+ */
+async function executeQuery(projectDir, databaseName, query) {
+  try {
+    await execAsync(
+      `wrangler d1 execute ${databaseName} --local --command="${query.replace(/"/g, '\\"')}"`,
+      { cwd: projectDir }
+    );
+    return true;
+  } catch (error) {
+    console.error('Query execution error:', error);
+    throw new Error('Failed to execute database query');
+  }
+}
+
+/**
+ * POST handler to sync migration files with the D1 migrations table.
+ * Uses the centralized helper to load the Wrangler configuration.
+ */
+export async function POST(req) {
+  try {
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) {
+      return NextResponse.json({ error: 'Project directory not configured' }, { status: 500 });
+    }
+
+    // Use the helper to get the Wrangler configuration
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult || !wranglerResult.config) {
+      return NextResponse.json({ error: 'Could not find Wrangler configuration' }, { status: 404 });
+    }
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) {
+      return NextResponse.json({ error: 'No D1 databases configured' }, { status: 404 });
+    }
+    // Get the first D1 database name from the configuration
+    const databaseName = config.d1_databases[0].database_name;
+
+    // Get migrations from the database and from the local file system
+    const [dbMigrations, fileMigrations] = await Promise.all([
+      getDatabaseMigrations(projectDir, databaseName),
+      getMigrationFiles(projectDir)
+    ]);
+
+    const dbMigrationsMap = new Map(dbMigrations.map(m => [m.name, m]));
+    const fileMigrationsMap = new Map(fileMigrations.map(m => [m.name, m]));
+
+    const changes = {
+      added: [],    // New files to add to d1_migrations
+      removed: [],  // Records to remove from d1_migrations
+      unchanged: [] // Files that match with records
+    };
+
+    // Identify migrations to remove (record exists in DB but file is missing)
+    for (const [name] of dbMigrationsMap) {
+      if (!fileMigrationsMap.has(name)) {
+        changes.removed.push(name);
+      }
+    }
+
+    // Remove records for missing files
+    if (changes.removed.length > 0) {
+      const names = changes.removed.map(name => `'${name}'`).join(',');
+      await executeQuery(
+        projectDir, 
+        databaseName,
+        `DELETE FROM d1_migrations WHERE name IN (${names});`
+      );
+    }
+
+    // Process each migration file: add new records and mark unchanged
+    for (const [name, fileMigration] of fileMigrationsMap) {
+      const dbMigration = dbMigrationsMap.get(name);
+      
+      if (!dbMigration) {
+        // Add new record for file
+        changes.added.push(name);
+        await executeQuery(
+          projectDir,
+          databaseName,
+          `INSERT OR REPLACE INTO d1_migrations (name, checksum) VALUES ('${name}', '${fileMigration.checksum}');`
+        );
+      } else {
+        changes.unchanged.push(name);
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      details: {
+        added: changes.added,
+        removed: changes.removed,
+        unchanged: changes.unchanged
+      }
+    });
+
+  } catch (error) {
+    console.error('Migration file sync error:', error);
+    return NextResponse.json({ 
+      error: error.message || 'Failed to sync migrations'
+    }, { 
+      status: 500 
+    });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

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

@@ -0,0 +1,277 @@
+// api/pull-remote/confirm/route.js
+
+import { NextResponse } from 'next/server';
+import { writeFile, mkdir, readdir, unlink } from 'fs/promises';
+import path from 'path';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { 
+  executeSQL,
+  ErrorTypes,
+  formatSQLStatement,
+  getMigrationFileContent
+} from '@/lib/sql-operations';
+import { getCurrentSchema, analyzeDependencies } from '@/lib/schema-operations';
+import { initMigrationsTable, recordMigration, getRemoteMigrations } from '@/lib/migrations.js';
+
+/**
+ * Applies the pull migrations by:
+ * 1. Fetching remote migration metadata.
+ * 2. For each remote migration, fetching the migration file content from remote.
+ * 3. Staging the migration files.
+ * 4. Performing a destructive update on local objects.
+ * 5. Resetting the local migrations table.
+ * 6. Applying staged migrations sequentially (writing files, recording and executing them).
+ * 7. Replacing the local migrations folder with the staged files.
+ *
+ * This completely replaces the local state with the remote state.
+ *
+ * @param {string} projectDir - The project directory.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ * @param {string} databaseName - The target D1 database name.
+ * @returns {object} Details of applied migrations.
+ */
+async function applyPullMigrations(projectDir, accountId, apiToken, databaseName) {
+  const env = {
+    ...process.env,
+    CLOUDFLARE_API_TOKEN: apiToken,
+    CLOUDFLARE_ACCOUNT_ID: accountId
+  };
+
+  try {
+    // Define paths for the main migrations folder and a temporary staging folder.
+    const migrationsDir = path.join(projectDir, 'migrations');
+    const stagingDir = path.join(projectDir, 'migrations-temp');
+
+    // Ensure both directories exist.
+    await mkdir(migrationsDir, { recursive: true });
+    await mkdir(stagingDir, { recursive: true });
+
+    // Clear out any existing files in the staging folder.
+    const stagedFilesList = await readdir(stagingDir).catch(() => []);
+    await Promise.all(stagedFilesList.map(file => unlink(path.join(stagingDir, file))));
+
+    // --- STEP 1: Fetch remote migration metadata ---
+    console.log('Fetching remote migration metadata...');
+    const remoteMigrations = await getRemoteMigrations(projectDir, databaseName, env);
+    console.log('Remote migration metadata:', remoteMigrations);
+
+    // --- STEP 2: For each remote migration, fetch its file content ---
+    console.log('Fetching migration file content from remote...');
+    const stagedFiles = new Map();
+    for (const migration of remoteMigrations) {
+      try {
+        const migrationFileName = migration.name; // Use the remote migration's name.
+        const content = await getMigrationFileContent(projectDir, databaseName, migrationFileName, env);
+        stagedFiles.set(migrationFileName, content);
+        console.log(`Staged migration file: ${migrationFileName}`);
+        await writeFile(path.join(stagingDir, migrationFileName), content, 'utf8');
+      } catch (fileError) {
+        console.error(`Error fetching content for migration ${migration.name}:`, fileError);
+        throw new Error(`Failed to fetch migration file content for ${migration.name}`);
+      }
+    }
+
+    // --- STEP 3: Fetch local schema for destructive update ---
+    console.log('Fetching local schema for destructive update...');
+    const currentSchema = await getCurrentSchema(projectDir, databaseName, env, false);
+    const tableSchema = currentSchema.filter(obj =>
+      obj.type === 'table' && obj.name && obj.name.toLowerCase() !== 'if'
+    );
+    console.log('Local table schema:', tableSchema);
+    const dropOrder = tableSchema.length > 0
+      ? analyzeDependencies(
+          tableSchema.map(obj => ({
+            tableName: obj.name,
+            sql: obj.sql,
+            type: obj.type
+          }))
+        )
+      : [];
+    console.log('Computed drop order:', dropOrder);
+
+    // --- STEP 4: Destructive update (all-or-nothing) ---
+    console.log('Beginning destructive update...');
+    try {
+      console.log('Disabling foreign keys...');
+      await executeSQL(projectDir, databaseName, 'PRAGMA foreign_keys=OFF;', env, false);
+      
+      // Drop triggers.
+      const triggers = currentSchema.filter(obj => obj.type === 'trigger');
+      for (const trigger of triggers) {
+        console.log(`Dropping trigger: ${trigger.name}`);
+        await executeSQL(
+          projectDir,
+          databaseName,
+          formatSQLStatement(`DROP TRIGGER IF EXISTS ${trigger.name}`),
+          env,
+          false
+        );
+      }
+      // Drop indexes.
+      const indexes = currentSchema.filter(obj => obj.type === 'index');
+      for (const index of indexes) {
+        console.log(`Dropping index: ${index.name}`);
+        await executeSQL(
+          projectDir,
+          databaseName,
+          formatSQLStatement(`DROP INDEX IF EXISTS ${index.name}`),
+          env,
+          false
+        );
+      }
+      // Drop tables in reverse dependency order.
+      for (const tableName of dropOrder.reverse()) {
+        console.log(`Dropping table: ${tableName}`);
+        await executeSQL(
+          projectDir,
+          databaseName,
+          formatSQLStatement(`DROP TABLE IF EXISTS ${tableName}`),
+          env,
+          false
+        );
+      }
+      console.log('Re-enabling foreign keys...');
+      await executeSQL(projectDir, databaseName, 'PRAGMA foreign_keys=ON;', env, false);
+    } catch (dropError) {
+      throw new Error(`Error dropping existing objects: ${dropError.message}`);
+    }
+
+    // --- STEP 5: Reset the local migrations table ---
+    try {
+      console.log('Resetting local migrations table...');
+      await initMigrationsTable(projectDir, databaseName, 'local', true);
+    } catch (initError) {
+      throw new Error(`Error resetting migrations table: ${initError.message}`);
+    }
+
+    // --- STEP 6: Apply staged migrations ---
+    // (Transactions removed because D1 operates in auto-commit mode)
+    const appliedPreview = { preview: [] };
+    let currentFilename = '';
+    try {
+      for (const [filename, content] of stagedFiles.entries()) {
+        currentFilename = filename;
+        console.log(`Applying migration: ${filename}`);
+        // Write the migration file to the main migrations folder.
+        await writeFile(path.join(migrationsDir, filename), content, 'utf8');
+
+        // Compute a checksum from the content.
+        const checksum = require('crypto')
+          .createHash('sha256')
+          .update(content)
+          .digest('hex');
+
+        console.log(`Recording migration: ${filename} with checksum ${checksum}`);
+        await recordMigration(
+          projectDir,
+          databaseName,
+          { name: filename, checksum },
+          env,
+          false
+        );
+
+        // Execute the migration SQL on the local database.
+        await executeSQL(projectDir, databaseName, content, env, false);
+
+        appliedPreview.preview.push({ migration: filename, action: 'applied' });
+      }
+    } catch (applyError) {
+      throw new Error(`Error applying migration ${currentFilename}: ${applyError.message}`);
+    }
+
+    // --- STEP 7: Replace main migrations folder with staged files ---
+    console.log('Replacing main migrations folder with staged files...');
+    const mainFiles = await readdir(migrationsDir).catch(() => []);
+    if (mainFiles.length) {
+      for (const file of mainFiles) {
+        console.log(`Deleting local migration file: ${file}`);
+        await unlink(path.join(migrationsDir, file));
+      }
+    }
+    for (const [filename, content] of stagedFiles.entries()) {
+      console.log(`Copying staged file ${filename} to main migrations folder`);
+      await writeFile(path.join(migrationsDir, filename), content, 'utf8');
+    }
+
+    console.log('Pull migration applied successfully.');
+    return {
+      appliedMigrations: Array.from(stagedFiles.keys()),
+      details: appliedPreview
+    };
+  } catch (error) {
+    console.error('Pull migration error:', error);
+    throw error;
+  }
+}
+
+/**
+ * POST handler for pull-remote confirm.
+ * Reads the Wrangler configuration (via findWranglerConfig) to obtain the D1 database name,
+ * then applies the pull migrations.
+ */
+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 applyPullMigrations(projectDir, accountId, apiToken, databaseName);
+    return NextResponse.json({
+      success: true,
+      message: 'Pull migrations applied successfully',
+      details: result
+    });
+  } catch (error) {
+    console.error('Pull remote confirm error:', error);
+    return NextResponse.json({
+      success: false,
+      error: {
+        type: error.type || ErrorTypes.EXECUTION_ERROR,
+        message: error.message || 'Failed to apply pull migrations',
+        details: error.details || {
+          suggestions: [
+            'Check your Cloudflare credentials',
+            'Verify database permissions',
+            'Ensure all migration files are accessible'
+          ]
+        }
+      }
+    }, { status: 500 });
+  }
+}
+
+/**
+ * OPTIONS handler for pre-flight requests.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}