d1s 0.2.1

package/dist/app/app/api/cloudflare/route.js

@@ -0,0 +1,146 @@
+// api/cloudflare/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+
+/**
+ * Validates the provided Cloudflare credentials by fetching databases.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ */
+async function validateCredentials(accountId, apiToken) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database`, {
+    headers: {
+      'Authorization': `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Invalid Cloudflare credentials');
+  }
+
+  return response.json();
+}
+
+/**
+ * Fetches the list of databases from Cloudflare and returns the one that matches the given name.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ * @param {string} databaseName - The name of the database to find.
+ */
+async function findDatabase(accountId, apiToken, databaseName) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database`, {
+    headers: {
+      'Authorization': `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch databases');
+  }
+
+  const { result } = await response.json();
+  return result.find(db => db.name === databaseName);
+}
+
+/**
+ * Creates a new database on Cloudflare.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ * @param {string} databaseName - The name for the new database.
+ */
+async function createDatabase(accountId, apiToken, databaseName) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      name: databaseName,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to create database');
+  }
+
+  return response.json();
+}
+
+/**
+ * API POST handler to validate credentials, read the Wrangler configuration, and ensure the D1 database exists.
+ */
+export async function POST(req) {
+  try {
+    // Parse accountId and apiToken from the request body.
+    const { accountId, apiToken } = await req.json();
+    const projectDir = process.env.D1_PROJECT_DIR;
+
+    // Check if the project directory is set.
+    if (!projectDir) {
+      return NextResponse.json(
+        { error: 'Project directory not configured' },
+        { status: 500 }
+      );
+    }
+
+    // Validate Cloudflare credentials.
+    await validateCredentials(accountId, apiToken);
+
+    // Retrieve the Wrangler configuration using the centralized 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;
+
+    // Ensure that at least one D1 database is configured.
+    if (!config.d1_databases?.length) {
+      return NextResponse.json(
+        { error: 'No D1 databases configured in Wrangler configuration' },
+        { status: 400 }
+      );
+    }
+
+    // Use the first configured D1 database.
+    const localDb = config.d1_databases[0];
+    
+    // Check if the database exists on Cloudflare.
+    let database = await findDatabase(accountId, apiToken, localDb.database_name);
+    
+    // If not found, create the database.
+    if (!database) {
+      const result = await createDatabase(accountId, apiToken, localDb.database_name);
+      database = result.result;
+    }
+
+    // Return the database details in the response.
+    return NextResponse.json({
+      success: true,
+      database: {
+        id: database.uuid,
+        name: database.name,
+      }
+    });
+
+  } catch (error) {
+    console.error('Cloudflare API error:', error);
+    return NextResponse.json(
+      { error: error.message },
+      { status: error.message.includes('Invalid credentials') ? 401 : 500 }
+    );
+  }
+}
+
+/**
+ * OPTIONS handler for pre-flight requests.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

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