d1s 0.2.10 → 0.2.12

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

@@ -1,174 +0,0 @@
-// 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 {
-  compareMigrations,
-  trackMigration,
-  createChecksum
-} from '@/lib/migrations';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-import logger from '@/lib/logger';
-
-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) {
-  logger.logRequest('POST', '/api/migrations/sync');
-
-  try {
-    const { accountId, apiToken } = await req.json();
-    const projectDir = process.env.D1_PROJECT_DIR;
-
-    if (!projectDir) {
-      logger.error('Project directory not configured');
-      return NextResponse.json(
-        { error: 'Project directory not configured' },
-        { status: 500 }
-      );
-    }
-
-    // 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) {
-    logger.logError(error, 'migrations-sync-route');
-    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/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 });
-}