d1s 0.2.13 → 0.3.0

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

@@ -1,122 +1,90 @@
 // api/pull-remote/preview/route.js
 
 import { NextResponse } from 'next/server';
+import { readdir } from 'fs/promises';
+import path from 'path';
 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';
 import logger from '@/lib/logger';
 
 /**
  * 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.
+ * Compares remote migration records against local migration files and shows
+ * which migrations will be applied locally.
  */
-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);
+async function generatePullPreview(projectDir, databaseName, dbMigrationsDir) {
+  const env = process.env;
 
-    // Build the preview object
-    const preview = {
-      preview: [],
-      totalTables: remoteSchema.length,
-      totalMigrations: remoteMigrations.length
-    };
+  const remoteMigrations = await getRemoteMigrations(projectDir, databaseName, env);
 
-    // 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
-        });
-      }
-    });
+  // Read local migration files to flag any that are missing
+  const migrationsDir = dbMigrationsDir || path.join(projectDir, 'migrations');
+  let localFiles = new Set();
+  try {
+    const files = await readdir(migrationsDir);
+    localFiles = new Set(files.filter(f => f.endsWith('.sql')));
+  } catch {
+    // migrations dir may not exist yet
+  }
 
-    // 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'
-      });
-    });
+  const preview = remoteMigrations.map(migration => ({
+    name: migration.name,
+    type: 'migration',
+    action: localFiles.has(migration.name) ? 'will be applied' : 'file missing locally',
+  }));
 
-    return preview;
-  } catch (error) {
-    logger.error('Pull preview generation error:', error);
-    throw error;
-  }
+  return {
+    preview,
+    totalMigrations: remoteMigrations.length,
+  };
 }
 
-/**
- * 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) {
+  if (process.env.D1_IS_PRO !== 'true') {
+    return NextResponse.json({ success: false, error: { type: 'PRO_REQUIRED', message: 'Pro license required. Run: d1s --license YOUR-KEY' } }, { status: 402 });
+  }
   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'
-        }
+        error: { type: ErrorTypes.VALIDATION_ERROR, message: 'Project directory not configured' }
       }, { status: 500 });
     }
 
-    // Load Wrangler configuration.
     const wranglerResult = await findWranglerConfig(projectDir);
-    if (!wranglerResult || !wranglerResult.config) {
+    if (!wranglerResult?.config) {
       return NextResponse.json({
         success: false,
-        error: { 
-          type: ErrorTypes.VALIDATION_ERROR, 
-          message: 'Could not find Wrangler configuration'
-        }
+        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.
+    const config = wranglerResult.config;
     if (!config.d1_databases?.length) {
       return NextResponse.json({
         success: false,
-        error: { 
-          type: ErrorTypes.VALIDATION_ERROR, 
-          message: 'No D1 databases configured'
-        }
+        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);
+    const body = await req.json().catch(() => ({}));
+    const dbParam = body?.db;
+    const dbConfig = dbParam
+      ? config.d1_databases.find(d => d.database_name === dbParam)
+      : config.d1_databases[0];
+    if (!dbConfig) {
+      return NextResponse.json({
+        success: false,
+        error: { type: ErrorTypes.VALIDATION_ERROR, message: `Database not found: ${dbParam}` }
+      }, { status: 400 });
+    }
+    const databaseName = dbConfig.database_name;
+    const migrationsDir = dbConfig.migrations_dir
+      ? path.join(projectDir, dbConfig.migrations_dir)
+      : path.join(projectDir, 'migrations');
+    const preview = await generatePullPreview(projectDir, databaseName, migrationsDir);
 
     return NextResponse.json({
       success: true,
@@ -136,9 +104,6 @@ export async function POST(req) {
   }
 }
 
-/**
- * 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

@@ -6,13 +6,10 @@ 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';
+import logger from '@/lib/logger';
 
-async function pushToRemote(projectDir, accountId, apiToken, databaseName, preview = false) {
-  const env = {
-    ...process.env,
-    CLOUDFLARE_ACCOUNT_ID: accountId,
-    CLOUDFLARE_API_TOKEN: apiToken,
-  };
+async function pushToRemote(projectDir, databaseName, preview = false, dbMigrationsDir) {
+  const env = process.env;
 
   try {
     // Create local migrations table (with checksum) and remote migrations table (without checksum)
@@ -50,14 +47,17 @@ async function pushToRemote(projectDir, accountId, apiToken, databaseName, previ
         return [];
       }
     };
+    const parsedRemoteRows = parseResults(remoteMigrations);
+    console.log(`[push-confirm] remote d1_migrations raw response: ${remoteMigrations}`);
+    console.log(`[push-confirm] remote d1_migrations parsed rows (${parsedRemoteRows.length}): ${JSON.stringify(parsedRemoteRows)}`);
     const remoteMigrationsMap = new Map(
-      parseResults(remoteMigrations).map(m => [m.name, m])
+      parsedRemoteRows.map(m => [m.name, m])
     );
 
     // Read migration files from disk.
-    const migrationsDir = path.join(projectDir, 'migrations');
+    const migrationsDir = dbMigrationsDir || path.join(projectDir, 'migrations');
     const files = await readdir(migrationsDir);
-    const migrationFiles = files.filter(f => f.endsWith('.sql')).sort();
+    const migrationFiles = files.filter(f => f.endsWith('.sql') && !/seed/i.test(f)).sort();
 
     const results = { applied: [], skipped: [], preview: [] };
 
@@ -75,6 +75,7 @@ for (const migrationFile of migrationFiles) {
     }
     // For remote, compare by migration file name.
     if (remoteMigrationsMap.has(migrationFile)) {
+      console.log(`[push-confirm] SKIP ${migrationFile} — found in remote d1_migrations`);
       previewRecord.action = 'skipped';
       previewRecord.reason = 'Already applied';
       results.preview.push(previewRecord);
@@ -92,7 +93,9 @@ for (const migrationFile of migrationFiles) {
     // 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);
+      console.log(`[push-confirm] tableExists(${tableName}, remote) = ${exists}`);
       if (exists) {
+        console.log(`[push-confirm] SKIP ${migrationFile} — table "${tableName}" already exists on remote`);
         previewRecord.action = 'skipped';
         previewRecord.reason = `Table "${tableName}" already exists`;
         results.skipped.push({ name: migrationFile, reason: previewRecord.reason });
@@ -145,8 +148,10 @@ for (const migrationFile of migrationFiles) {
 }
 
 export async function POST(req) {
+  if (process.env.D1_IS_PRO !== 'true') {
+    return NextResponse.json({ success: false, error: { type: 'PRO_REQUIRED', message: 'Pro license required. Run: d1s --license YOUR-KEY' } }, { status: 402 });
+  }
   try {
-    const { accountId, apiToken } = await req.json();
     const projectDir = process.env.D1_PROJECT_DIR;
     if (!projectDir) {
       return NextResponse.json({
@@ -168,9 +173,23 @@ export async function POST(req) {
         error: { message: 'No D1 databases configured', type: ErrorTypes.VALIDATION_ERROR }
       }, { status: 400 });
     }
-    const databaseName = config.d1_databases[0].database_name;
+    const body = await req.json().catch(() => ({}));
+    const dbParam = body?.db;
+    const dbConfig = dbParam
+      ? config.d1_databases.find(d => d.database_name === dbParam)
+      : config.d1_databases[0];
+    if (!dbConfig) {
+      return NextResponse.json({
+        success: false,
+        error: { message: `Database not found: ${dbParam}`, type: ErrorTypes.VALIDATION_ERROR }
+      }, { status: 400 });
+    }
+    const databaseName = dbConfig.database_name;
+    const migrationsDir = dbConfig.migrations_dir
+      ? path.join(projectDir, dbConfig.migrations_dir)
+      : path.join(projectDir, 'migrations');
     // Force preview to be false for actual execution.
-    const result = await pushToRemote(projectDir, accountId, apiToken, databaseName, false);
+    const result = await pushToRemote(projectDir, databaseName, false, migrationsDir);
     return NextResponse.json({
       success: true,
       message: 'Successfully pushed migrations to remote',

package/dist/app/api/push-remote/preview/route.js

@@ -15,12 +15,8 @@ import logger from '@/lib/logger';
  *
  * Note: For remote, we no longer use the checksum.
  */
-async function pushToRemote(projectDir, accountId, apiToken, databaseName, preview = true) {
-  const env = {
-    ...process.env,
-    CLOUDFLARE_ACCOUNT_ID: accountId,
-    CLOUDFLARE_API_TOKEN: apiToken,
-  };
+async function pushToRemote(projectDir, databaseName, preview = true, dbMigrationsDir) {
+  const env = process.env;
 
   try {
     // Create local migrations table (with checksum)
@@ -60,14 +56,17 @@ async function pushToRemote(projectDir, accountId, apiToken, databaseName, previ
       }
     };
     // Use migration file name as key
+    const parsedRemoteRows = parseResults(remoteMigrations);
+    console.log(`[push-preview] remote d1_migrations raw response: ${remoteMigrations}`);
+    console.log(`[push-preview] remote d1_migrations parsed rows (${parsedRemoteRows.length}): ${JSON.stringify(parsedRemoteRows)}`);
     const remoteMigrationsMap = new Map(
-      parseResults(remoteMigrations).map(m => [m.name, m])
+      parsedRemoteRows.map(m => [m.name, m])
     );
 
     // Read migration files from disk.
-    const migrationsDir = path.join(projectDir, 'migrations');
+    const migrationsDir = dbMigrationsDir || path.join(projectDir, 'migrations');
     const files = await readdir(migrationsDir);
-    const migrationFiles = files.filter(f => f.endsWith('.sql')).sort();
+    const migrationFiles = files.filter(f => f.endsWith('.sql') && !/seed/i.test(f)).sort();
 
     const results = { applied: [], skipped: [], preview: [] };
 
@@ -118,8 +117,10 @@ async function pushToRemote(projectDir, accountId, apiToken, databaseName, previ
  * then calls pushToRemote in preview mode and returns a preview.
  */
 export async function POST(req) {
+  if (process.env.D1_IS_PRO !== 'true') {
+    return NextResponse.json({ success: false, error: { type: 'PRO_REQUIRED', message: 'Pro license required. Run: d1s --license YOUR-KEY' } }, { status: 402 });
+  }
   try {
-    const { accountId, apiToken } = await req.json();
     const projectDir = process.env.D1_PROJECT_DIR;
     if (!projectDir) {
       return NextResponse.json({
@@ -150,8 +151,22 @@ export async function POST(req) {
         }
       }, { status: 400 });
     }
-    const databaseName = config.d1_databases[0].database_name;
-    const result = await pushToRemote(projectDir, accountId, apiToken, databaseName, true);
+    const body = await req.json().catch(() => ({}));
+    const dbParam = body?.db;
+    const dbConfig = dbParam
+      ? config.d1_databases.find(d => d.database_name === dbParam)
+      : config.d1_databases[0];
+    if (!dbConfig) {
+      return NextResponse.json({
+        success: false,
+        error: { type: ErrorTypes.VALIDATION_ERROR, message: `Database not found: ${dbParam}` }
+      }, { status: 400 });
+    }
+    const databaseName = dbConfig.database_name;
+    const migrationsDir = dbConfig.migrations_dir
+      ? path.join(projectDir, dbConfig.migrations_dir)
+      : path.join(projectDir, 'migrations');
+    const result = await pushToRemote(projectDir, databaseName, true, migrationsDir);
     return NextResponse.json({
       success: true,
       message: 'Preview generated for migrations to be pushed to remote',

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

@@ -31,7 +31,7 @@ export async function POST(req) {
     }
 
     // Extract the SQL query from the request body.
-    const { query } = await req.json();
+    const { query, db } = await req.json();
 
     if (logger.shouldLog('debug')) {
       logger.debug('Received query:', query);
@@ -63,9 +63,17 @@ export async function POST(req) {
       );
     }
 
-    // Use the first configured database.
-    const databaseName = config.d1_databases[0].database_name;
-    // console.log('Using database:', databaseName);
+    // Resolve target database — use body.db if provided, else fall back to first
+    const dbConfig = db
+      ? config.d1_databases.find(d => d.database_name === db)
+      : config.d1_databases[0];
+    if (!dbConfig) {
+      return NextResponse.json(
+        { success: false, error: { message: `Database not found: ${db}` } },
+        { status: 404 }
+      );
+    }
+    const databaseName = dbConfig.database_name;
 
     // Parse the query into individual SQL statements.
     let statements = parseQuery(query);
@@ -80,9 +88,9 @@ export async function POST(req) {
 
     // Validate each parsed statement.
     statements = statements.map(validateStatement);
-    // console.log('Validated statements:', statements);
 
-    // Initialize the migrations table (if it doesn't already exist).
+    // Initialize the migrations table only for non-read-only queries.
+    // Skipping for SELECT/PRAGMA/EXPLAIN avoids an extra wrangler/miniflare process per read query.
     const createMigrationsTable = `
       CREATE TABLE IF NOT EXISTS d1_migrations (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -91,11 +99,16 @@ export async function POST(req) {
         applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
       );
     `;
-    await executeSQL(projectDir, databaseName, createMigrationsTable);
+    const isReadOnly = statements.every(s => {
+      const u = s.sql.trim().toUpperCase();
+      return u.startsWith('SELECT') || u.startsWith('PRAGMA') || u.startsWith('EXPLAIN');
+    });
+    if (!isReadOnly) {
+      await executeSQL(projectDir, databaseName, createMigrationsTable, {}, false, dbConfig);
+    }
 
     // Determine whether the query involves any schema changes.
     const hasSchemaChanges = statements.some(isSchemaChange);
-    // console.log('Has schema changes:', hasSchemaChanges);
 
     let result;
     if (hasSchemaChanges) {
@@ -113,15 +126,13 @@ export async function POST(req) {
       // For data modification queries, execute the statements.
       const results = [];
       for (const stmt of statements) {
-        // console.log('Executing data modification:', stmt.sql);
-        const output = await executeSQL(projectDir, databaseName, stmt.sql);
-        
+        const output = await executeSQL(projectDir, databaseName, stmt.sql, {}, false, dbConfig);
+
         try {
           const parsed = JSON.parse(output);
           const queryResults = parsed[0]?.results || [];
           results.push(...queryResults);
         } catch (parseError) {
-          // console.log('Non-JSON output:', output);
           continue;
         }
       }
@@ -135,8 +146,8 @@ export async function POST(req) {
     return NextResponse.json(result);
 
   } catch (error) {
-    logger.logError(error, 'query-route');
     const parsedError = parseSQLError(error);
+    logger.error(`✗ ${parsedError.message}`);
     
     const statusCode = 
       error.type === ErrorTypes.VALIDATION_ERROR ? 400 :

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

@@ -0,0 +1,63 @@
+// api/schema/route.js
+// Returns all tables with column schemas and FK relationships.
+
+import { NextResponse } from 'next/server';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+
+const execAsync = promisify(exec);
+
+async function runPragma(databaseName, query, projectDir) {
+  const { stdout } = await execAsync(
+    `wrangler d1 execute ${databaseName} --local --command="${query.replace(/"/g, '\\"')}" --json`,
+    { cwd: projectDir }
+  );
+  const result = JSON.parse(stdout);
+  return result[0]?.results || [];
+}
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const dbParam = searchParams.get('db');
+
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) throw new Error('Project directory not configured');
+
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult?.config) throw new Error('No Wrangler configuration found');
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) throw new Error('No D1 databases configured');
+
+    const dbConfig = dbParam
+      ? config.d1_databases.find(d => d.database_name === dbParam)
+      : config.d1_databases[0];
+    if (!dbConfig) throw new Error(`Database not found: ${dbParam}`);
+    const databaseName = dbConfig.database_name;
+
+    // Get all user tables
+    const tableRows = await runPragma(
+      databaseName,
+      `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%' ORDER BY name;`,
+      projectDir
+    );
+    const tableNames = tableRows.map(r => r.name);
+
+    // Run sequentially to avoid SQLITE_BUSY (database locked) errors
+    const tables = [];
+    for (const name of tableNames) {
+      const columns = await runPragma(databaseName, `PRAGMA table_info(${name});`, projectDir);
+      const foreignKeys = await runPragma(databaseName, `PRAGMA foreign_key_list(${name});`, projectDir);
+      tables.push({ name, columns, foreignKeys });
+    }
+
+    return NextResponse.json({ success: true, tables });
+  } catch (error) {
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}

package/dist/app/api/tables/[name]/import/route.js

@@ -0,0 +1,112 @@
+// api/tables/[name]/import/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import { sanitizeTableName, sanitizeColumnName } from '@/lib/sql-sanitizer.js';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { executeLocalSQL } from '@/lib/local-db.js';
+import logger from '@/lib/logger';
+
+const execAsync = promisify(exec);
+const BATCH_SIZE = 100;
+
+async function executeD1Command(sql, projectDir, dbConfig) {
+  // Try direct SQLite access first (fast path)
+  const localOutput = executeLocalSQL(projectDir, dbConfig, sql);
+  if (localOutput !== null) return JSON.parse(localOutput);
+
+  // Fall back to wrangler CLI
+  const databaseName = dbConfig.database_name;
+  const { stdout } = await execAsync(
+    `wrangler d1 execute ${databaseName} --local --command="${sql.replace(/"/g, '\\"')}" --json`,
+    { cwd: projectDir }
+  );
+  return JSON.parse(stdout);
+}
+
+export async function POST(req, context) {
+  try {
+    const params = await context.params;
+    const { name } = params;
+
+    const { rows, db } = await req.json();
+
+    if (!Array.isArray(rows) || rows.length === 0) {
+      return NextResponse.json(
+        { success: false, error: 'No rows provided' },
+        { status: 400 }
+      );
+    }
+
+    const projectDir = process.env.D1_PROJECT_DIR;
+    if (!projectDir) throw new Error('Project directory not configured');
+
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult?.config) throw new Error('No Wrangler configuration found');
+    const config = wranglerResult.config;
+    if (!config.d1_databases?.length) throw new Error('No D1 databases configured');
+
+    const dbConfig = db
+      ? config.d1_databases.find(d => d.database_name === db)
+      : config.d1_databases[0];
+    if (!dbConfig) throw new Error(`Database not found: ${db}`);
+    const databaseName = dbConfig.database_name;
+
+    const sanitizedTableName = sanitizeTableName(name);
+    const columns = Object.keys(rows[0]).map(sanitizeColumnName);
+
+    let imported = 0;
+    const errors = [];
+
+    // Process in batches to avoid wrangler command size limits
+    for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+      const batch = rows.slice(i, i + BATCH_SIZE);
+      const valuesList = batch.map(row => {
+        const vals = columns.map(col => {
+          const rawCol = Object.keys(rows[0])[columns.indexOf(col)];
+          const v = row[rawCol];
+          if (v === null || v === undefined || v === '') return 'NULL';
+          if (typeof v === 'number') return v;
+          return `'${String(v).replace(/'/g, "''")}'`;
+        });
+        return `(${vals.join(', ')})`;
+      });
+
+      const sql = `INSERT INTO ${sanitizedTableName} (${columns.join(', ')}) VALUES ${valuesList.join(', ')};`;
+
+      try {
+        await executeD1Command(sql, projectDir, dbConfig);
+        imported += batch.length;
+      } catch (err) {
+        logger.error(`Import batch ${i}-${i + BATCH_SIZE} failed:`, err);
+        errors.push({ batch: i, error: err.message });
+        // Continue with remaining batches
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      imported,
+      failed: rows.length - imported,
+      errors,
+    });
+  } catch (error) {
+    logger.error('Import error:', error);
+    return NextResponse.json(
+      { success: false, error: error.message },
+      { status: 500 }
+    );
+  }
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    },
+  });
+}