d1s 0.2.1

package/src/lib/sql-operations.js

@@ -0,0 +1,557 @@
+// sql-operations.js
+
+import { promisify } from 'util';
+import { exec } from 'child_process';
+
+const execAsync = promisify(exec);
+
+// ---------------------------------------------------------------------
+// Operation & Error Types (for schema changes and SQL execution)
+// ---------------------------------------------------------------------
+export const Operations = {
+  CREATE_TABLE: 'CREATE_TABLE',
+  ALTER_TABLE: 'ALTER_TABLE',
+  DROP_TABLE: 'DROP_TABLE',
+  CREATE_INDEX: 'CREATE_INDEX',
+  DROP_INDEX: 'DROP_INDEX',
+  DATA_MODIFICATION: 'DATA_MODIFICATION'
+};
+
+export const ErrorTypes = {
+  VALIDATION_ERROR: 'VALIDATION_ERROR',
+  SYNTAX_ERROR: 'SYNTAX_ERROR',
+  EXECUTION_ERROR: 'EXECUTION_ERROR',
+  DEPENDENCY_ERROR: 'DEPENDENCY_ERROR'
+};
+
+// ---------------------------------------------------------------------
+// SQL Parsing and Validation
+// ---------------------------------------------------------------------
+
+export function isSchemaChange(statement) {
+  return statement.type !== Operations.DATA_MODIFICATION;
+}
+
+/**
+ * Enhanced parseStatement:
+ * Detects the type of SQL statement and, for ALTER TABLE, captures rename details.
+ */
+export function parseStatement(sql) {
+  const cleanSql = sql.trim().replace(/\s+/g, ' ');
+  const upperSql = cleanSql.toUpperCase();
+
+  if (upperSql.startsWith('CREATE TABLE')) {
+    // Optionally, you might want to capture column definitions here
+    return {
+      type: Operations.CREATE_TABLE,
+      tableName: extractTableName(cleanSql, 'CREATE TABLE'),
+      sql: cleanSql,
+      description: 'create-table'
+    };
+  }
+
+  if (upperSql.startsWith('ALTER TABLE')) {
+    const tableName = extractTableName(cleanSql, 'ALTER TABLE');
+    let description = '';
+
+    // Check for RENAME COLUMN operations first.
+    if (upperSql.includes('RENAME')) {
+      const renameMatch = cleanSql.match(/RENAME\s+(?:COLUMN\s+)?([\w$]+)\s+TO\s+([\w$]+)/i);
+      if (renameMatch) {
+        description = `rename-${renameMatch[1]}-to-${renameMatch[2]}`;
+      }
+    }
+    // Check for ADD COLUMN operations.
+    else if (upperSql.includes('ADD COLUMN')) {
+      const addMatch = cleanSql.match(/ADD\s+COLUMN\s+([\w$]+)(\s+[\w()]+)?/i);
+      if (addMatch) {
+        // Capture column name and optionally the data type
+        const column = addMatch[1];
+        const dataType = addMatch[2] ? addMatch[2].trim().replace(/\s+/g, '-') : '';
+        description = dataType ? `add-${column}-${dataType}` : `add-${column}`;
+      }
+    }
+    // Check for DROP COLUMN operations.
+    else if (upperSql.includes('DROP COLUMN')) {
+      const dropMatch = cleanSql.match(/DROP\s+COLUMN\s+([\w$]+)/i);
+      if (dropMatch) {
+        description = `drop-${dropMatch[1]}`;
+      }
+    }
+    // Check for MODIFY COLUMN or CHANGE COLUMN operations.
+    else if (upperSql.includes('MODIFY COLUMN') || upperSql.includes('CHANGE COLUMN')) {
+      const modifyMatch = cleanSql.match(/(?:MODIFY|CHANGE)\s+COLUMN\s+([\w$]+)(\s+[\w()]+)?/i);
+      if (modifyMatch) {
+        const column = modifyMatch[1];
+        const newDefinition = modifyMatch[2] ? modifyMatch[2].trim().replace(/\s+/g, '-') : '';
+        description = newDefinition ? `modify-${column}-to-${newDefinition}` : `modify-${column}`;
+      }
+    }
+
+    return {
+      type: Operations.ALTER_TABLE,
+      tableName,
+      sql: cleanSql,
+      description // will be an empty string if none of the above matches
+    };
+  }
+
+  if (upperSql.startsWith('DROP TABLE')) {
+    return {
+      type: Operations.DROP_TABLE,
+      tableName: extractTableName(cleanSql, 'DROP TABLE'),
+      sql: cleanSql,
+      description: 'drop-table'
+    };
+  }
+
+  if (upperSql.startsWith('CREATE INDEX') || upperSql.startsWith('CREATE UNIQUE INDEX')) {
+    // Extract table name via the existing helper (if needed elsewhere)
+    const tableName = extractTableNameFromIndex(cleanSql);
+    // Extract the index name.
+    const indexMatch = cleanSql.match(/INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?([\w$]+)/i);
+    const indexName = indexMatch ? indexMatch[1] : '';
+    // Extract the columns from the ON clause.
+    const onMatch = cleanSql.match(/ON\s+[\w$]+\s*\(([^)]+)\)/i);
+    const columns = onMatch ? onMatch[1].trim() : '';
+    // Remove spaces and replace commas with hyphens.
+    const formattedColumns = columns.replace(/\s+/g, '').replace(/,/g, '-').toLowerCase();
+    
+    // Build a description that uses the index name,
+    // and appends the columns if they are not already included.
+    let description = indexName;
+    if (formattedColumns && !description.toLowerCase().includes(formattedColumns)) {
+      description += `-${formattedColumns}`;
+    }
+    
+    return {
+      type: Operations.CREATE_INDEX,
+      tableName,
+      sql: cleanSql,
+      description // e.g. "idx_movies_name" or "idx_movies_name-name"
+    };
+  }  
+
+  if (upperSql.startsWith('DROP INDEX')) {
+    const tableName = extractTableNameFromIndex(cleanSql);
+    const indexMatch = cleanSql.match(/DROP\s+INDEX\s+(?:IF\s+EXISTS\s+)?([\w$]+)/i);
+    const indexName = indexMatch ? indexMatch[1] : '';
+    return {
+      type: Operations.DROP_INDEX,
+      tableName,
+      sql: cleanSql,
+      description: indexName ? `drop-index-${indexName}` : 'drop-index'
+    };
+  }
+
+  // Default case: treat as data modification.
+  return {
+    type: Operations.DATA_MODIFICATION,
+    sql: cleanSql,
+    description: 'data-modification'
+  };
+}
+
+export function validateStatement(statement) {
+  if (statement.type !== Operations.DATA_MODIFICATION && !statement.tableName) {
+    throw {
+      type: ErrorTypes.VALIDATION_ERROR,
+      message: `Invalid SQL statement: unable to determine table name for "${statement.type}".`,
+      details: { sql: statement.sql }
+    };
+  }
+  return statement;
+}
+
+// Helpers for extracting table names.
+export function extractTableName(sql, prefix) {
+  const match = sql.match(new RegExp(`${prefix}\\s+(?:IF\\s+(?:NOT\\s+)?EXISTS\\s+)?([\\w_]+)`, 'i'));
+  return match ? match[1] : null;
+}
+
+export function extractTableNameFromIndex(sql) {
+  const match = sql.match(/ON\s+([\w_]+)/i);
+  return match ? match[1] : null;
+}
+
+/**
+ * Improved helper to extract table name from migration filename.
+ * Handles patterns such as:
+ * - 0001_create-users-table.sql  => table name: users
+ * - 0002_alter-orders-table.sql  => table name: orders
+ * - 0003_create-index_orders.sql => table name: orders (for indexes)
+ */
+export async function extractTableNameFromMigration(filename) {
+  // Pattern 1: Matches filenames like "20250218072608_create-table_new_table.sql"
+  const createRegex1 = /^\d+_create[-_]table[_-](.+)\.sql$/i;
+  // Pattern 2: Matches filenames like "0001_create-books-table.sql"
+  const createRegex2 = /^\d+_create[-](.+)-table\.sql$/i;
+
+  // For alter migrations:
+  // Pattern 1: e.g., "20250218072608_alter-table_new_table_add-column_notes.sql"
+  const alterRegex1 = /^\d+_alter[-_]table[_-](.+?)(?:[_-].+)?\.sql$/i;
+  // Pattern 2: In case a similar alternate format exists.
+  const alterRegex2 = /^\d+_alter[-](.+?)-table(?:[_-].+)?\.sql$/i;
+
+  // Index migrations:
+  const indexRegex = /^\d+_create[-_]index[-_](.+)\.sql$/i;
+
+  let match = filename.match(createRegex1);
+  if (match) return match[1];
+
+  match = filename.match(createRegex2);
+  if (match) return match[1];
+
+  match = filename.match(alterRegex1);
+  if (match) return match[1];
+
+  match = filename.match(alterRegex2);
+  if (match) return match[1];
+
+  match = filename.match(indexRegex);
+  if (match) return match[1];
+
+  return null;
+}
+
+export function removeSQLComments(sql) {
+  return sql
+    .split('\n')
+    .filter(line => !line.trim().startsWith('--'))
+    .join('\n')
+    .trim();
+}
+
+/**
+ * Checks if a table already exists in the given database.
+ *
+ * @param {string} projectDir - The project directory.
+ * @param {string} databaseName - The D1 database name.
+ * @param {object} env - Environment variables.
+ * @param {string} tableName - The table name to check.
+ * @param {boolean} [remote=false] - Whether to check the remote database.
+ * @returns {Promise<boolean>} True if the table exists; otherwise, false.
+ */
+export async function tableExists(projectDir, databaseName, env, tableName, remote = false) {
+  // Query the sqlite_master table for the given table name.
+  const query = `SELECT name FROM sqlite_master WHERE type='table' AND name = '${tableName}' COLLATE NOCASE;`;
+
+  const result = await executeSQL(projectDir, databaseName, query, env, remote);
+  try {
+    const jsonStart = result.indexOf('[');
+    if (jsonStart !== -1) {
+      const jsonStr = result.substring(jsonStart);
+      const parsed = JSON.parse(jsonStr);
+      const results = parsed[0]?.results || [];
+      return results.length > 0;
+    }
+    return false;
+  } catch (e) {
+    console.error("Error parsing tableExists result:", e);
+    return false;
+  }
+}
+
+// Parse a full SQL query (multiple statements) into an array of parsed statement objects.
+export function parseQuery(query) {
+  const noComments = query
+    .replace(/--.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .trim();
+  return noComments
+    .split(';')
+    .map(stmt => stmt.trim())
+    .filter(stmt => stmt.length > 0)
+    .map(stmt => parseStatement(stmt + ';'));
+}
+
+// ---------------------------------------------------------------------
+// SQL Execution
+// ---------------------------------------------------------------------
+
+/**
+ * Executes a SQL command via Wrangler.
+ * Supports both local and remote execution.
+ */
+export async function executeSQL(projectDir, databaseName, sql, env = {}, remote = false) {
+  try {
+    // Use let so we can modify the SQL if needed.
+    let cleanSQL = sql.trim().replace(/\s+/g, ' ');
+    const upperSQL = cleanSQL.toUpperCase();
+
+    // If it's an index creation and doesn't already have IF NOT EXISTS, add it.
+    if ((upperSQL.startsWith("CREATE INDEX") || upperSQL.startsWith("CREATE UNIQUE INDEX")) &&
+        !upperSQL.includes("IF NOT EXISTS")) {
+      if (upperSQL.startsWith("CREATE UNIQUE INDEX")) {
+        cleanSQL = cleanSQL.replace(/CREATE\s+UNIQUE\s+INDEX/i, "CREATE UNIQUE INDEX IF NOT EXISTS");
+      } else {
+        cleanSQL = cleanSQL.replace(/CREATE\s+INDEX/i, "CREATE INDEX IF NOT EXISTS");
+      }
+    }
+
+    const isWindows = process.platform === 'win32';
+    const npxCommand = isWindows ? 'npx.cmd' : 'npx';
+    const executionFlag = remote ? '--remote' : '--local';
+    const command = `${npxCommand} wrangler d1 execute ${databaseName} ${executionFlag} --command="${cleanSQL.replace(/"/g, '\\"')}"`;
+    const execOptions = {
+      cwd: projectDir,
+      env: { ...process.env, ...env },
+      maxBuffer: 1024 * 1024 * 10,
+      shell: true
+    };
+    console.log('Executing command:', command);
+    const { stdout, stderr } = await execAsync(command, execOptions);
+    if (stderr && !stderr.includes('🌀')) {
+      throw new Error(stderr);
+    }
+    try {
+      const jsonStart = stdout.indexOf('[');
+      if (jsonStart !== -1) {
+        return stdout.substring(jsonStart);
+      }
+    } catch (parseError) {
+      console.warn('JSON parse warning:', parseError);
+    }
+    return stdout;
+  } catch (error) {
+    console.error('SQL Execution error:', error);
+    // Instead of creating a new error object, preserve the original error details
+    throw {
+      type: ErrorTypes.EXECUTION_ERROR,
+      message: 'Failed to execute SQL command',
+      details: {
+        command: error.cmd,
+        stderr: error.stderr,
+        stdout: error.stdout,
+        originalError: error.message,
+        suggestions: [
+          'Ensure Node.js and Wrangler are installed',
+          'Check npx in PATH', 
+          'Verify the D1 database exists and is configured',
+          'Check wrangler.toml configuration'
+        ]
+      }
+    };
+  }
+}
+
+// ---------------------------------------------------------------------
+// SQL Formatting and Helper Functions
+// ---------------------------------------------------------------------
+
+export function formatSQLStatement(sql) {
+  const cleanSql = sql.trim();
+  const upperSql = cleanSql.toUpperCase();
+  if (upperSql.startsWith('CREATE TABLE')) return formatCreateTable(cleanSql);
+  if (upperSql.startsWith('CREATE INDEX') || upperSql.startsWith('CREATE UNIQUE INDEX'))
+    return formatCreateIndex(cleanSql);
+  if (upperSql.startsWith('ALTER TABLE')) return formatAlterTable(cleanSql);
+  if (upperSql.startsWith('DROP TABLE') || upperSql.startsWith('DROP INDEX'))
+    return formatDropStatement(cleanSql);
+  if (upperSql.startsWith('INSERT INTO')) return formatInsert(cleanSql);
+  if (upperSql.startsWith('UPDATE')) return formatUpdate(cleanSql);
+  if (upperSql.startsWith('DELETE FROM')) return formatDelete(cleanSql);
+  if (upperSql.startsWith('SELECT')) return formatSelect(cleanSql);
+  return cleanSql + ';';
+}
+
+export function formatCreateTable(sql) {
+  const match = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s*\(([\s\S]*)\)/i);
+  if (!match) return sql;
+  const [ , tableName, columnDefs ] = match;
+  const parts = splitSQLParts(columnDefs);
+  const definitions = parts.map(part => part.trim()).filter(Boolean);
+  return `CREATE TABLE ${tableName} (\n  ${definitions.join(',\n  ')}\n);`;
+}
+
+export function formatDropStatement(sql) {
+  const match = sql.match(/DROP\s+(TABLE|INDEX)\s+(?:IF\s+EXISTS\s+)?(\w+)/i);
+  if (!match) return sql;
+  const [ , type, name ] = match;
+  return `DROP ${type} IF EXISTS ${name};`;
+}
+
+export function formatCreateIndex(sql) {
+  const match = sql.match(/CREATE\s+(UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s+ON\s+(\w+)\s*\((.*)\)/i);
+  if (!match) return sql;
+  const [ , unique, indexName, tableName, columns ] = match;
+  const formattedColumns = columns.split(',').map(col => col.trim()).join(', ');
+  return `CREATE ${unique || ''}INDEX ${indexName} ON ${tableName} (${formattedColumns});`;
+}
+
+export function formatAlterTable(sql) {
+  const match = sql.match(/ALTER\s+TABLE\s+(\w+)\s+(.*)/i);
+  if (!match) return sql;
+  const [ , tableName, alterations ] = match;
+  const parts = splitSQLParts(alterations);
+  if (parts.length === 1) return `ALTER TABLE ${tableName} ${parts[0]};`;
+  return `ALTER TABLE ${tableName}\n${parts.map((part, i) => `  ${part}${i < parts.length - 1 ? ',' : ';'}`).join('\n')}`;
+}
+
+export function formatInsert(sql) {
+  const match = sql.match(/INSERT\s+INTO\s+(\w+)\s*(\([^)]+\))?\s*VALUES\s*(.+)/i);
+  if (!match) return sql;
+  const [ , table, columns, values ] = match;
+  const valueSets = splitSQLParts(values);
+  let formatted = `INSERT INTO ${table}${columns ? ` ${columns}` : ''}\nVALUES\n`;
+  formatted += valueSets.map((set, i) => `  ${set}${i < valueSets.length - 1 ? ',' : ';'}`).join('\n');
+  return formatted;
+}
+
+export function formatUpdate(sql) {
+  const match = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/i);
+  if (!match) return sql;
+  const [ , table, sets, where ] = match;
+  const setClauses = splitSQLParts(sets);
+  let formatted = `UPDATE ${table}\nSET\n${setClauses.map(clause => `  ${clause.trim()}`).join(',\n')}`;
+  if (where) formatted += `\nWHERE\n  ${where.trim()}`;
+  return formatted + ';';
+}
+
+export function formatDelete(sql) {
+  const match = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/i);
+  if (!match) return sql;
+  const [ , table, where ] = match;
+  let formatted = `DELETE FROM ${table}`;
+  if (where) formatted += `\nWHERE\n  ${where.trim()}`;
+  return formatted + ';';
+}
+
+export function formatSelect(sql) {
+  const parts = sql.match(/SELECT\s+(.+?)\s+FROM\s+(.+?)(?:\s+WHERE\s+(.+?))?(?:\s+GROUP\s+BY\s+(.+?))?(?:\s+HAVING\s+(.+?))?(?:\s+ORDER\s+BY\s+(.+?))?(?:\s+LIMIT\s+(.+?))?$/i);
+  if (!parts) return sql;
+  const [ , columns, tables, where, groupBy, having, orderBy, limit ] = parts;
+  let formatted = `SELECT\n  ${columns.split(',').map(c => c.trim()).join(',\n  ')}\nFROM\n  ${tables.trim()}`;
+  if (where) formatted += `\nWHERE\n  ${where.trim()}`;
+  if (groupBy) formatted += `\nGROUP BY\n  ${groupBy.trim()}`;
+  if (having) formatted += `\nHAVING\n  ${having.trim()}`;
+  if (orderBy) formatted += `\nORDER BY\n  ${orderBy.trim()}`;
+  if (limit) formatted += `\nLIMIT ${limit.trim()}`;
+  return formatted + ';';
+}
+
+export function splitSQLParts(sql) {
+  const parts = [];
+  let currentPart = '';
+  let parenCount = 0;
+  let inQuote = false;
+  let prevChar = '';
+  for (let char of sql) {
+    if (char === '"' && prevChar !== '\\') inQuote = !inQuote;
+    if (!inQuote) {
+      if (char === '(') parenCount++;
+      if (char === ')') parenCount--;
+    }
+    if (char === ',' && parenCount === 0 && !inQuote) {
+      parts.push(currentPart.trim());
+      currentPart = '';
+    } else {
+      currentPart += char;
+    }
+    prevChar = char;
+  }
+  if (currentPart.trim()) parts.push(currentPart.trim());
+  return parts;
+}
+
+/**
+ * Formats a full migration content by splitting statements and formatting each.
+ */
+export function formatMigrationContent(sql) {
+  const statements = sql.split(';').map(stmt => stmt.trim()).filter(stmt => stmt.length > 0);
+  return statements.map(stmt => formatSQLStatement(stmt)).join('\n\n') + '\n';
+}
+
+/**
+ * Fetches the SQL content of a migration file from remote.
+ * This version does not use an extra dummy SELECT.
+ * It issues a harmless valid SQL statement (SELECT '' AS content;)
+ * alongside the migration directive, so that Wrangler executes the command.
+ *
+ * @param {string} projectDir - The project directory.
+ * @param {string} databaseName - The D1 database name.
+ * @param {string} filename - The migration filename.
+ * @param {object} env - Environment variables.
+ * @returns {Promise<string>} The migration file content.
+ */
+
+ export async function getMigrationFileContent(projectDir, databaseName, migrationFile, env) {
+  try {
+    // Extract table name using improved helper
+    const tableName = await extractTableNameFromMigration(migrationFile);
+    let sql;
+
+    if (tableName) {
+      // Try getting SQL from sqlite_master for table
+      const result = await executeSQL(
+        projectDir,
+        databaseName,
+        `SELECT sql FROM sqlite_master WHERE type='table' AND name='${tableName}';`,
+        env,
+        true
+      );
+
+      try {
+        const parsed = JSON.parse(result);
+        sql = parsed[0]?.results?.[0]?.sql;
+      } catch (e) {
+        console.error('Error parsing sqlite_master result:', e);
+      }
+    }
+
+    // If we couldn't get the SQL from table, try index
+    if (!sql && migrationFile.includes('create-index')) {
+      const indexMatch = migrationFile.match(/create-index[-_]([^_.]+)/);
+      if (indexMatch) {
+        const result = await executeSQL(
+          projectDir,
+          databaseName,
+          `SELECT sql FROM sqlite_master WHERE type='index' AND name='${indexMatch[1]}';`,
+          env,
+          true
+        );
+        const parsed = JSON.parse(result);
+        sql = parsed[0]?.results?.[0]?.sql;
+      }
+    }
+
+    // If still no SQL, try fetching any object matching the name pattern
+    if (!sql && tableName) {
+      const result = await executeSQL(
+        projectDir,
+        databaseName,
+        `SELECT sql FROM sqlite_master WHERE name LIKE '%${tableName}%' LIMIT 1;`,
+        env,
+        true
+      );
+      try {
+        const parsed = JSON.parse(result);
+        sql = parsed[0]?.results?.[0]?.sql;
+      } catch (e) {
+        console.error('Error parsing fallback result:', e);
+      }
+    }
+
+    if (!sql) {
+      throw new Error(`Could not retrieve SQL content for migration: ${migrationFile}`);
+    }
+
+    // Format and return the SQL
+    return sql + ';';
+
+  } catch (error) {
+    throw {
+      type: ErrorTypes.EXECUTION_ERROR,
+      message: `Failed to get migration file content: ${error.message}`,
+      details: { 
+        file: migrationFile, 
+        error: error.message,
+        suggestions: [
+          'Check if the table exists in the remote database',
+          'Verify the migration filename follows the expected pattern',
+          'Ensure you have permissions to access the remote database'
+        ]
+      }
+    };
+  }
+}

package/src/lib/utils.js

@@ -0,0 +1,6 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}