d1s 0.2.11 → 0.2.13

package/src/lib/sql-operations.js

@@ -1,647 +0,0 @@
-// sql-operations.js
-
-import { promisify } from 'util';
-import { exec } from 'child_process';
-import logger from '@/lib/logger';
-
-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] : '';
-    
-    // For index migrations, simply use the index name as the description.
-    const description = indexName;
-    
-    return {
-      type: Operations.CREATE_INDEX,
-      tableName,
-      sql: cleanSql,
-      description // now simply the index name, e.g. "idx_technology_timestamp"
-    };
-  }
-    
-
-  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, '\\"')}"`;
-    
-    // Only log in development
-    if (logger.shouldLog('debug')) {
-      logger.debug('Executing command:', command);
-    }
-    
-    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'
-        ]
-      }
-    };
-  }
-}
-
-/**
- * Fetches the latest `limit` records for a given table from the remote database.
- *
- * This implementation uses the executeSQL function with the remote flag enabled.
- * It orders the results based on the provided ordering column. If no ordering column is provided,
- * it falls back to the default "id" column.
- *
- * @param {string} projectDir - The project directory.
- * @param {string} databaseName - The D1 database name.
- * @param {string} tableName - The table to fetch records for.
- * @param {object} env - Environment variables (including credentials).
- * @param {number} limit - The number of records to fetch.
- * @param {string} [orderingColumn="id"] - The column to order by.
- * @returns {Promise<Array<object>>} Array of row objects.
- */
-export async function fetchRemoteTableData(
-  projectDir,
-  databaseName,
-  tableName,
-  env,
-  limit,
-  orderingColumn = "id"
-) {
-  // Use the provided ordering column; if not provided, default to "id".
-  const query = `SELECT * FROM "${tableName}" ORDER BY "${orderingColumn}" DESC LIMIT ${limit};`;
-  try {
-    // Execute the SQL command on the remote database.
-    const result = await executeSQL(projectDir, databaseName, query, env, true);
-    
-    // ExecuteSQL returns stdout that should contain a JSON array starting from a '['.
-    const jsonStart = result.indexOf('[');
-    if (jsonStart === -1) {
-      throw new Error(`Unexpected result format: ${result}`);
-    }
-    const jsonStr = result.substring(jsonStart);
-    const parsed = JSON.parse(jsonStr);
-    // Assuming the structure: parsed[0].results contains the rows.
-    const rows = parsed[0]?.results || [];
-    return rows;
-  } catch (error) {
-    logger.error(`Error fetching remote data for table ${tableName}:`, error);
-    throw error;
-  }
-}
-
-/**
- * Generates a bulk insert SQL statement for the specified table and rows.
- *
- * This function constructs a single INSERT statement that inserts multiple rows.
- * It escapes single quotes in string values. You may need to extend this for
- * additional data types (e.g., numbers, dates, booleans) or more complex structures.
- *
- * @param {string} tableName - The table to insert into.
- * @param {Array<object>} rows - An array of objects, each representing a row.
- * @returns {string} The bulk insert SQL statement.
- */
-export function generateBulkInsertSQL(tableName, rows) {
-  if (!rows || rows.length === 0) return '';
-  
-  // Get the list of columns from the first row object.
-  const columns = Object.keys(rows[0]);
-  const columnList = columns.map(col => `"${col}"`).join(', ');
-
-  // Build the values list for each row.
-  const valuesList = rows.map(row => {
-    const values = columns.map(col => {
-      const value = row[col];
-      if (value === null || value === undefined) return 'NULL';
-      // For simplicity, treat the value as a string.
-      return `'${String(value).replace(/'/g, "''")}'`;
-    }).join(', ');
-    return `(${values})`;
-  }).join(', ');
-
-  return `INSERT INTO "${tableName}" (${columnList}) VALUES ${valuesList};`;
-}
-
-// ---------------------------------------------------------------------
-// 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;
-
-    // For non-index migrations, try getting SQL from sqlite_master for table
-    if (tableName && !migrationFile.includes('create-index')) {
-      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 and it's an index migration, try fetching via index name.
-    if (!sql && migrationFile.includes('create-index')) {
-      const indexMatch = migrationFile.match(/create-index[_-](.+)\.sql$/i);
-      if (indexMatch) {
-        let indexName = indexMatch[1]; // e.g. "idx_technology_timestamp-technology-timestamp"
-        let result = await executeSQL(
-          projectDir,
-          databaseName,
-          `SELECT sql FROM sqlite_master WHERE type='index' AND name='${indexName}' COLLATE NOCASE;`,
-          env,
-          true
-        );
-        let parsed = JSON.parse(result);
-        sql = parsed[0]?.results?.[0]?.sql;
-        // Fallback: if no result, try using only the part before the first hyphen.
-        if (!sql) {
-          const fallbackIndexName = indexName.split('-')[0]; // "idx_technology_timestamp"
-          result = await executeSQL(
-            projectDir,
-            databaseName,
-            `SELECT sql FROM sqlite_master WHERE type='index' AND name='${fallbackIndexName}' COLLATE NOCASE;`,
-            env,
-            true
-          );
-          parsed = JSON.parse(result);
-          sql = parsed[0]?.results?.[0]?.sql;
-        }
-      }
-    }    
-
-    // If still no SQL and it's not an index migration, try a fallback query
-    if (!sql && tableName && !migrationFile.includes('create-index')) {
-      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

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

package/src/lib/version-utils.js

@@ -1,34 +0,0 @@
-// lib/version-utils.js
-
-/**
- * Compares semantic versions to determine if v2 is newer than v1
- * @param {string} v1 - First version (e.g. "1.0.0")
- * @param {string} v2 - Second version (e.g. "1.0.1")
- * @returns {boolean} True if v2 is newer than v1
- */
-export function isNewerVersion(v1, v2) {
-    if (!v1 || !v2) return false;
-    
-    // Split versions by dots
-    const v1Parts = v1.split('.').map(Number);
-    const v2Parts = v2.split('.').map(Number);
-    
-    // Compare major, minor, and patch versions
-    for (let i = 0; i < 3; i++) {
-      if (v2Parts[i] > v1Parts[i]) return true;
-      if (v2Parts[i] < v1Parts[i]) return false;
-    }
-    
-    // If we reach here, versions are equal
-    return false;
-  }
-  
-  /**
-   * Formats version strings for display by removing leading 'v' if present
-   * @param {string} version - The version string (e.g. "v1.0.0" or "1.0.0")
-   * @returns {string} Formatted version (e.g. "1.0.0")
-   */
-  export function formatVersion(version) {
-    if (!version) return '';
-    return version.startsWith('v') ? version.substring(1) : version;
-  }