d1s 0.2.11 → 0.2.12

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

@@ -1,172 +0,0 @@
-// 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/dist/app/app/api/pull-data/confirm/route.js

@@ -1,230 +0,0 @@
-// api/pull-data/confirm/route.js
-
-import { NextResponse } from 'next/server';
-import { executeSQL } from '@/lib/sql-operations';
-import { getCurrentSchema } from '@/lib/schema-operations';
-import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
-import logger from '@/lib/logger';
-import {
-  fetchRemoteTableData as fetchRemoteDataHelper,
-  generateBulkInsertSQL
-} from '@/lib/sql-operations';
-
-/**
- * Helper to extract the ordering column (primary key) from a table's schema.
- * Assumes that each table’s schema object contains a "columns" array with an "isPrimaryKey" flag.
- *
- * @param {object} tableSchema - Schema info for the table.
- * @returns {string} The column name to use for ordering.
- */
-function getOrderingColumn(tableSchema) {
-  const pkColumn = tableSchema.columns?.find(col => col.isPrimaryKey);
-  const orderingCol = pkColumn ? pkColumn.name : 'rowid';
-  logger.debug(`Determined ordering column for table ${tableSchema.name || 'unknown'}: ${orderingCol}`);
-  return orderingCol;
-}
-
-/**
- * Computes an insertion order for tables based on their foreign key dependencies.
- * The returned array is sorted so that if table A is referenced by table B,
- * then A appears earlier in the list.
- *
- * @param {Array<object>} tableSchemas - Array of table schema objects.
- * @returns {Array<string>} Ordered array of table names.
- */
-function computeInsertionOrder(tableSchemas) {
-  // Build a dependency graph: key = table name, value = set of tables that this table depends on.
-  const graph = {};
-  tableSchemas.forEach(table => {
-    // Initialize graph for this table.
-    graph[table.name] = new Set();
-    // Use a regex to find FOREIGN KEY references in the table's SQL.
-    // This regex assumes the foreign key clause looks like:
-    // FOREIGN KEY (...) REFERENCES referencedTable(...)
-    const fkRegex = /FOREIGN KEY\s*\([^)]*\)\s+REFERENCES\s+(\w+)/gi;
-    let match;
-    while ((match = fkRegex.exec(table.sql)) !== null) {
-      const referencedTable = match[1];
-      graph[table.name].add(referencedTable);
-    }
-  });
-  logger.debug('Computed dependency graph:', graph);
-  
-  // Topological sort (depth-first search) to compute insertion order.
-  const sorted = [];
-  const visited = {}; // 'temp' = visiting, 'perm' = done
-
-  function visit(tableName) {
-    if (visited[tableName] === 'temp') {
-      throw new Error(`Cycle detected in dependencies at table ${tableName}`);
-    }
-    if (!visited[tableName]) {
-      visited[tableName] = 'temp';
-      // Visit all tables that this table depends on.
-      graph[tableName].forEach(dep => {
-        // Only visit if the dependency is in our graph (i.e. among our tables)
-        if (graph[dep]) {
-          visit(dep);
-        }
-      });
-      visited[tableName] = 'perm';
-      sorted.push(tableName);
-    }
-  }
-
-  Object.keys(graph).forEach(tableName => {
-    if (!visited[tableName]) {
-      visit(tableName);
-    }
-  });
-
-  logger.debug('Computed insertion order (parent tables first):', sorted);
-  return sorted;
-}
-
-/**
- * Applies the data pull by:
- * 1. Fetching the local schema to determine table names and primary keys.
- * 2. Computing the insertion order so that parent tables are inserted before child tables.
- * 3. For each table (in insertion order), fetching the latest 100 records from the remote database.
- * 4. Generating a bulk insert statement and executing it.
- *
- * This function aborts the entire process if any insert fails.
- *
- * @param {string} projectDir
- * @param {string} accountId
- * @param {string} apiToken
- * @param {string} databaseName
- * @returns {object} Details of data pulled.
- */
-async function applyDataPull(projectDir, accountId, apiToken, databaseName) {
-  logger.debug('Starting data pull process...');
-  const env = {
-    ...process.env,
-    CLOUDFLARE_API_TOKEN: apiToken,
-    CLOUDFLARE_ACCOUNT_ID: accountId
-  };
-
-  logger.debug('Fetching current schema for data pull...');
-  const currentSchema = await getCurrentSchema(projectDir, databaseName, env, false);
-  // Filter for table objects that have a name.
-  const tableSchemas = currentSchema.filter(obj => obj.type === 'table' && obj.name);
-  logger.debug('Local table schema for data pull:', tableSchemas.map(t => t.name));
-
-  // Compute insertion order based on foreign key dependencies.
-  const insertionOrder = computeInsertionOrder(tableSchemas);
-  logger.debug('Final computed insertion order:', insertionOrder);
-
-  // Process each table in the computed insertion order.
-  for (const tableName of insertionOrder) {
-    const table = tableSchemas.find(t => t.name === tableName);
-    if (!table) {
-      logger.debug(`Skipping table ${tableName} as it is not in the current schema list.`);
-      continue;
-    }
-    logger.debug(`Processing table: ${tableName}`);
-    const orderingColumn = getOrderingColumn(table);
-    logger.debug(`Fetching data for table: ${tableName} ordered by ${orderingColumn}`);
-
-    // Fetch remote data.
-    const rows = await fetchRemoteDataHelper(
-      projectDir,
-      databaseName,
-      tableName,
-      env,
-      75,
-      orderingColumn
-    );
-    logger.debug(`Fetched ${rows.length} records for table: ${tableName}`);
-
-    if (rows.length > 0) {
-      const insertSQL = generateBulkInsertSQL(tableName, rows);
-      logger.debug(`Generated bulk insert SQL for ${tableName}: ${insertSQL}`);
-
-      try {
-        // Execute the insert SQL directly.
-        await executeSQL(projectDir, databaseName, insertSQL, env, false);
-        logger.debug(`Bulk inserted ${rows.length} records into table: ${tableName}`);
-      } catch (insertError) {
-        logger.error(`Error inserting data into table ${tableName}:`, insertError);
-        // Abort the entire process to preserve data integrity.
-        throw new Error(`Data pull failed for table ${tableName}: ${insertError.message}`);
-      }
-    } else {
-      logger.debug(`No data fetched for table: ${tableName}`);
-    }
-  }
-  logger.debug('Data pull process completed successfully.');
-  return { message: 'All data pulled successfully.' };
-}
-
-export async function POST(req) {
-  try {
-    logger.debug('Received request for data pull.');
-    const { accountId, apiToken } = await req.json();
-    const projectDir = process.env.D1_PROJECT_DIR;
-    if (!projectDir) {
-      return NextResponse.json(
-        {
-          success: false,
-          error: {
-            type: '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: '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: 'VALIDATION_ERROR',
-            message: 'No D1 databases configured'
-          }
-        },
-        { status: 400 }
-      );
-    }
-    const databaseName = config.d1_databases[0].database_name;
-    logger.debug(`Initiating data pull for database: ${databaseName}`);
-    const result = await applyDataPull(projectDir, accountId, apiToken, databaseName);
-    logger.debug('Data pull result:', result);
-    return NextResponse.json({
-      success: true,
-      message: result.message,
-      details: result
-    });
-  } catch (error) {
-    logger.error('Pull data confirm error:', error);
-    return NextResponse.json(
-      {
-        success: false,
-        error: {
-          type: error.type || 'EXECUTION_ERROR',
-          message: error.message || 'Failed to apply data pull'
-        }
-      },
-      { status: 500 }
-    );
-  }
-}
-
-export async function OPTIONS() {
-  return new NextResponse(null, { status: 204 });
-}

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

@@ -1,278 +0,0 @@
-// 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';
-import logger from '@/lib/logger';
-
-/**
- * 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 ---
-    logger.debug('Fetching remote migration metadata...');
-    const remoteMigrations = await getRemoteMigrations(projectDir, databaseName, env);
-    logger.debug('Remote migration metadata:', remoteMigrations);
-
-    // --- STEP 2: For each remote migration, fetch its file content ---
-    logger.debug('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);
-        logger.debug(`Staged migration file: ${migrationFileName}`);
-        await writeFile(path.join(stagingDir, migrationFileName), content, 'utf8');
-      } catch (fileError) {
-        logger.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 ---
-    logger.debug('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'
-    );
-    logger.debug('Local table schema:', tableSchema);
-    const dropOrder = tableSchema.length > 0
-      ? analyzeDependencies(
-          tableSchema.map(obj => ({
-            tableName: obj.name,
-            sql: obj.sql,
-            type: obj.type
-          }))
-        )
-      : [];
-    logger.debug('Computed drop order:', dropOrder);
-
-    // --- STEP 4: Destructive update (all-or-nothing) ---
-    logger.debug('Beginning destructive update...');
-    try {
-      logger.debug('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) {
-        logger.debug(`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) {
-        logger.debug(`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()) {
-        logger.debug(`Dropping table: ${tableName}`);
-        await executeSQL(
-          projectDir,
-          databaseName,
-          formatSQLStatement(`DROP TABLE IF EXISTS ${tableName}`),
-          env,
-          false
-        );
-      }
-      logger.debug('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 {
-      logger.debug('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;
-        logger.debug(`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');
-
-        logger.debug(`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 ---
-    logger.debug('Replacing main migrations folder with staged files...');
-    const mainFiles = await readdir(migrationsDir).catch(() => []);
-    if (mainFiles.length) {
-      for (const file of mainFiles) {
-        logger.debug(`Deleting local migration file: ${file}`);
-        await unlink(path.join(migrationsDir, file));
-      }
-    }
-    for (const [filename, content] of stagedFiles.entries()) {
-      logger.debug(`Copying staged file ${filename} to main migrations folder`);
-      await writeFile(path.join(migrationsDir, filename), content, 'utf8');
-    }
-
-    logger.debug('Pull migration applied successfully.');
-    return {
-      appliedMigrations: Array.from(stagedFiles.keys()),
-      details: appliedPreview
-    };
-  } catch (error) {
-    logger.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) {
-    logger.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 });
-}