d1s 0.2.1

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

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