sql-kite 1.0.7 → 1.0.8

package/server/routes/migrations.js

@@ -0,0 +1,332 @@
+import { readdirSync, readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'fs';
+import { join } from 'path';
+import  crypto from 'crypto';
+
+export default async function migrationsRoutes(fastify, options) {
+  // List all migrations
+  fastify.get('/', async (request, reply) => {
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      // Ensure migrations directory exists
+      if (!existsSync(migrationsPath)) {
+        return [];
+      }
+
+      const files = readdirSync(migrationsPath).filter(f => f.endsWith('.sql')).sort();
+
+      const applied = metaDb.prepare(`
+        SELECT filename, applied_at FROM migrations WHERE branch = ? ORDER BY id
+      `).all(currentBranch);
+
+      const appliedMap = new Map(applied.map(m => [m.filename, m.applied_at]));
+
+      return files.map(filename => {
+        const filePath = join(migrationsPath, filename);
+        const content = readFileSync(filePath, 'utf-8');
+        const stats = statSync(filePath);
+        const checksum = crypto.createHash('sha256').update(content).digest('hex');
+        const appliedAt = appliedMap.get(filename);
+
+        return {
+          filename,
+          applied: appliedMap.has(filename),
+          content,
+          branch: currentBranch,
+          created_at: stats.birthtime.toISOString(),
+          applied_at: appliedAt || null,
+          checksum,
+          author: 'SQL Kite'
+        };
+      });
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Create a new migration file
+  fastify.post('/create', async (request, reply) => {
+    const { name, sql } = request.body;
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    if (!name || !sql) {
+      return reply.code(400).send({ error: 'Name and SQL are required' });
+    }
+
+    try {
+      // Ensure migrations directory exists
+      if (!existsSync(migrationsPath)) {
+        mkdirSync(migrationsPath, { recursive: true });
+      }
+
+      // Get next migration number
+      const existingFiles = readdirSync(migrationsPath).filter(f => f.endsWith('.sql'));
+      const numbers = existingFiles
+        .map(f => parseInt(f.split('_')[0]))
+        .filter(n => !isNaN(n));
+      const nextNum = numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
+
+      // Create filename
+      const filename = `${String(nextNum).padStart(3, '0')}_${name}.sql`;
+      const filePath = join(migrationsPath, filename);
+
+      // Write migration file
+      writeFileSync(filePath, sql, 'utf-8');
+
+      // Log event in current branch
+      metaDb.prepare(`
+        INSERT INTO events (branch, type, data)
+        VALUES (?, 'migration_created', ?)
+      `).run(currentBranch, JSON.stringify({ filename, name }));
+
+      return {
+        success: true,
+        filename,
+        path: filePath
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Apply migration
+  fastify.post('/apply', async (request, reply) => {
+    const { filename } = request.body;
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+    const db = fastify.getUserDb();
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      // Check if already applied in this branch
+      const existing = metaDb.prepare(`
+        SELECT id FROM migrations WHERE branch = ? AND filename = ?
+      `).get(currentBranch, filename);
+
+      if (existing) {
+        return reply.code(400).send({ error: 'Migration already applied in this branch' });
+      }
+
+      // Read and execute migration
+      const sql = readFileSync(join(migrationsPath, filename), 'utf-8');
+      db.exec(sql);
+
+      // Mark as applied in this branch
+      metaDb.prepare(`
+        INSERT INTO migrations (branch, filename) VALUES (?, ?)
+      `).run(currentBranch, filename);
+
+      // Log event in this branch
+      metaDb.prepare(`
+        INSERT INTO events (branch, type, data)
+        VALUES (?, 'migration_applied', ?)
+      `).run(currentBranch, JSON.stringify({ filename }));
+
+      return { success: true, branch: currentBranch };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Apply all pending migrations
+  fastify.post('/apply-all', async (request, reply) => {
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+    const db = fastify.getUserDb();
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      const allFiles = readdirSync(migrationsPath).filter(f => f.endsWith('.sql')).sort();
+
+      const applied = metaDb.prepare(`
+        SELECT filename FROM migrations WHERE branch = ?
+      `).all(currentBranch);
+
+      const appliedSet = new Set(applied.map(m => m.filename));
+      const pendingFiles = allFiles.filter(f => !appliedSet.has(f));
+
+      const results = [];
+
+      for (const filename of pendingFiles) {
+        try {
+          const sql = readFileSync(join(migrationsPath, filename), 'utf-8');
+          db.exec(sql);
+
+          metaDb.prepare(`
+            INSERT INTO migrations (branch, filename) VALUES (?, ?)
+          `).run(currentBranch, filename);
+
+          metaDb.prepare(`
+            INSERT INTO events (branch, type, data)
+            VALUES (?, 'migration_applied', ?)
+          `).run(currentBranch, JSON.stringify({ filename }));
+
+          results.push({ filename, success: true });
+        } catch (error) {
+          results.push({ filename, success: false, error: error.message });
+          // Stop on first error
+          break;
+        }
+      }
+
+      return {
+        success: true,
+        branch: currentBranch,
+        applied: results
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Delete migration (only if NEVER applied in ANY branch)
+  fastify.delete('/:filename', async (request, reply) => {
+    const { filename } = request.params;
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      // CRITICAL: Check if migration was applied in ANY branch (not just current)
+      const appliedInAnyBranch = metaDb.prepare(`
+        SELECT branch FROM migrations WHERE filename = ? LIMIT 1
+      `).get(filename);
+
+      if (appliedInAnyBranch) {
+        return reply.code(400).send({
+          error: `Migration cannot be deleted. It has been applied in branch "${appliedInAnyBranch.branch}".`,
+          applied_in_branch: appliedInAnyBranch.branch,
+          reason: 'APPLIED_IN_BRANCH'
+        });
+      }
+
+      // Migration has never been applied - safe to delete
+      const filePath = join(migrationsPath, filename);
+      
+      if (!existsSync(filePath)) {
+        return reply.code(404).send({ error: 'Migration file not found' });
+      }
+
+      // Delete the file
+      const { unlinkSync } = await import('fs');
+      unlinkSync(filePath);
+
+      // Log deletion event
+      metaDb.prepare(`
+        INSERT INTO events (branch, type, data)
+        VALUES (?, 'migration_deleted', ?)
+      `).run(currentBranch, JSON.stringify({ filename }));
+
+      return {
+        success: true,
+        filename,
+        message: 'Migration deleted successfully'
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Get migration application status across ALL branches
+  fastify.get('/:filename/status', async (request, reply) => {
+    const { filename } = request.params;
+    const metaDb = fastify.getMetaDb();
+
+    try {
+      const applications = metaDb.prepare(`
+        SELECT branch, applied_at 
+        FROM migrations 
+        WHERE filename = ?
+        ORDER BY applied_at DESC
+      `).all(filename);
+
+      return {
+        filename,
+        applied_in_branches: applications.map(a => a.branch),
+        can_delete: applications.length === 0,
+        applications
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Export single migration file
+  fastify.get('/:filename/export', async (request, reply) => {
+    const { filename } = request.params;
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+
+    try {
+      const filePath = join(migrationsPath, filename);
+      
+      if (!existsSync(filePath)) {
+        return reply.code(404).send({ error: 'Migration file not found' });
+      }
+
+      const content = readFileSync(filePath, 'utf-8');
+
+      // Set headers for file download
+      reply.header('Content-Type', 'text/plain');
+      reply.header('Content-Disposition', `attachment; filename="${filename}"`);
+      
+      return content;
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Export all applied migrations for current branch (ordered)
+  fastify.get('/export/applied', async (request, reply) => {
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+    const migrationsPath = join(fastify.projectPath, 'migrations');
+
+    try {
+      // Get applied migrations in order
+      const applied = metaDb.prepare(`
+        SELECT filename, applied_at 
+        FROM migrations 
+        WHERE branch = ? 
+        ORDER BY id
+      `).all(currentBranch);
+
+      if (applied.length === 0) {
+        return reply.code(400).send({ 
+          error: 'No migrations have been applied in this branch' 
+        });
+      }
+
+      // Build combined SQL file
+      let combinedSql = `-- Applied migrations for branch: ${currentBranch}\n`;
+      combinedSql += `-- Generated: ${new Date().toISOString()}\n`;
+      combinedSql += `-- Total migrations: ${applied.length}\n\n`;
+
+      for (const migration of applied) {
+        const filePath = join(migrationsPath, migration.filename);
+        
+        if (existsSync(filePath)) {
+          const content = readFileSync(filePath, 'utf-8');
+          combinedSql += `-- ========================================\n`;
+          combinedSql += `-- Migration: ${migration.filename}\n`;
+          combinedSql += `-- Applied: ${migration.applied_at}\n`;
+          combinedSql += `-- ========================================\n\n`;
+          combinedSql += content;
+          combinedSql += `\n\n`;
+        }
+      }
+
+      const filename = `${fastify.projectPath.split(/[\\/]/).pop()}_${currentBranch}_migrations.sql`;
+
+      reply.header('Content-Type', 'text/plain');
+      reply.header('Content-Disposition', `attachment; filename="${filename}"`);
+      
+      return combinedSql;
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+}

package/server/routes/query.js

@@ -0,0 +1,67 @@
+export default async function queryRoutes(fastify, options) {
+  // Execute SQL query
+  fastify.post('/', async (request, reply) => {
+    const { sql } = request.body;
+    const db = fastify.getUserDb();
+    const metaDb = fastify.getMetaDb();
+    
+    if (!sql || sql.trim() === '') {
+      return reply.code(400).send({ error: 'SQL query is required' });
+    }
+    
+    const startTime = Date.now();
+    
+    try {
+      const trimmedSql = sql.trim().toUpperCase();
+      let result;
+      
+      // Determine query type
+      if (trimmedSql.startsWith('SELECT') || trimmedSql.startsWith('PRAGMA')) {
+        // Read query
+        result = {
+          type: 'select',
+          rows: db.prepare(sql).all(),
+          executionTime: Date.now() - startTime
+        };
+      } else {
+        // Write query (INSERT, UPDATE, DELETE, CREATE, etc.)
+        const info = db.prepare(sql).run();
+        result = {
+          type: 'write',
+          changes: info.changes,
+          lastInsertRowid: info.lastInsertRowid,
+          executionTime: Date.now() - startTime
+        };
+      }
+      
+      // Log to timeline
+      metaDb.prepare(`
+        INSERT INTO events (type, data)
+        VALUES ('sql_executed', ?)
+      `).run(JSON.stringify({
+        sql,
+        type: result.type,
+        executionTime: result.executionTime,
+        changes: result.changes,
+        rowCount: result.rows?.length
+      }));
+      
+      return result;
+    } catch (error) {
+      // Log error
+      metaDb.prepare(`
+        INSERT INTO events (type, data)
+        VALUES ('sql_error', ?)
+      `).run(JSON.stringify({
+        sql,
+        error: error.message,
+        executionTime: Date.now() - startTime
+      }));
+      
+      return reply.code(400).send({
+        error: error.message,
+        sql
+      });
+    }
+  });
+}

package/server/routes/schema.js

@@ -0,0 +1,206 @@
+export default async function schemaRoutes(fastify, options) {
+  // Get full database schema
+  fastify.get('/', async (request, reply) => {
+    const db = fastify.getUserDb();
+    
+    const schema = db.prepare(`
+      SELECT type, name, sql
+      FROM sqlite_master
+      WHERE sql NOT NULL
+        AND name NOT LIKE 'sqlite_%'
+        AND name NOT LIKE '_studio_%'
+      ORDER BY type, name
+    `).all();
+    
+    return {
+      tables: schema.filter(s => s.type === 'table'),
+      indexes: schema.filter(s => s.type === 'index'),
+      views: schema.filter(s => s.type === 'view'),
+      triggers: schema.filter(s => s.type === 'trigger')
+    };
+  });
+  
+  // Get foreign keys for a table
+  fastify.get('/foreign-keys/:tableName', async (request, reply) => {
+    const { tableName } = request.params;
+    const db = fastify.getUserDb();
+    
+    try {
+      const foreignKeys = db.prepare(`PRAGMA foreign_key_list(${tableName})`).all();
+      return foreignKeys;
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+  
+  // Get indexes for a table
+  fastify.get('/indexes/:tableName', async (request, reply) => {
+    const { tableName } = request.params;
+    const db = fastify.getUserDb();
+    
+    try {
+      const indexes = db.prepare(`PRAGMA index_list(${tableName})`).all();
+      return indexes;
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Export full schema as SQL (state-based, not history)
+  fastify.get('/export', async (request, reply) => {
+    const db = fastify.getUserDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      // Get all schema objects
+      const schema = db.prepare(`
+        SELECT type, name, sql
+        FROM sqlite_master
+        WHERE sql NOT NULL
+          AND name NOT LIKE 'sqlite_%'
+          AND name NOT LIKE '_studio_%'
+        ORDER BY 
+          CASE type
+            WHEN 'table' THEN 1
+            WHEN 'index' THEN 2
+            WHEN 'view' THEN 3
+            WHEN 'trigger' THEN 4
+            ELSE 5
+          END,
+          name
+      `).all();
+
+      // Build SQL export
+      let exportSql = `-- Full schema export\\n`;
+      exportSql += `-- Branch: ${currentBranch}\\n`;
+      exportSql += `-- Generated: ${new Date().toISOString()}\\n`;
+      exportSql += `-- \\n`;
+      exportSql += `-- This is current database state, not migration history.\\n`;
+      exportSql += `\\n`;
+
+      let currentType = null;
+
+      for (const obj of schema) {
+        // Add section headers
+        if (obj.type !== currentType) {
+          currentType = obj.type;
+          exportSql += `\\n-- ========================================\\n`;
+          exportSql += `-- ${obj.type.toUpperCase()}S\\n`;
+          exportSql += `-- ========================================\\n\\n`;
+        }
+
+        exportSql += `-- ${obj.name}\\n`;
+        exportSql += obj.sql + ';\\n\\n';
+      }
+
+      const projectName = fastify.projectName;
+      const filename = `${projectName}_${currentBranch}_schema.sql`;
+
+      reply.header('Content-Type', 'text/plain');
+      reply.header('Content-Disposition', `attachment; filename=\"${filename}\"`);
+      
+      return exportSql;
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  // Get ER diagram data (tables + columns + foreign key relations)
+  fastify.get('/er', async (request, reply) => {
+    const db = fastify.getUserDb();
+
+    try {
+      const inferRelations = String(request.query?.infer || '').toLowerCase() === 'true'
+      // Get all tables (excluding SQLite internal tables)
+      const tables = db.prepare(`
+        SELECT name 
+        FROM sqlite_master 
+        WHERE type='table' 
+          AND name NOT LIKE 'sqlite_%'
+          AND name NOT LIKE '_studio_%'
+        ORDER BY name
+      `).all();
+
+      const tablesWithColumns = [];
+      const relations = [];
+      const primaryKeysByTable = {};
+
+      for (const table of tables) {
+        // Get column info
+        const columns = db.prepare(`PRAGMA table_info(${table.name})`).all();
+        
+        // Get foreign keys
+        const foreignKeys = db.prepare(`PRAGMA foreign_key_list(${table.name})`).all();
+
+        // Map columns to our format
+        const formattedColumns = columns.map(col => ({
+          name: col.name,
+          type: col.type,
+          pk: col.pk === 1,
+          notnull: col.notnull === 1,
+          dflt_value: col.dflt_value
+        }));
+
+        tablesWithColumns.push({
+          name: table.name,
+          columns: formattedColumns
+        });
+
+        primaryKeysByTable[table.name] = formattedColumns
+          .filter(col => col.pk)
+          .map(col => col.name);
+
+        // Map foreign keys to relations
+        for (const fk of foreignKeys) {
+          relations.push({
+            from: `${table.name}.${fk.from}`,
+            to: `${fk.table}.${fk.to}`,
+            fromTable: table.name,
+            toTable: fk.table,
+            fromColumn: fk.from,
+            toColumn: fk.to
+          });
+        }
+      }
+
+      const relationKeySet = new Set(
+        relations.map(rel => `${rel.fromTable}|${rel.fromColumn}|${rel.toTable}|${rel.toColumn}`)
+      );
+
+      if (inferRelations || relations.length === 0) {
+        for (const table of tablesWithColumns) {
+          for (const column of table.columns) {
+            if (column.pk) continue;
+
+            for (const [targetTable, pkColumns] of Object.entries(primaryKeysByTable)) {
+              if (targetTable === table.name) continue;
+
+              if (pkColumns.includes(column.name)) {
+                const key = `${table.name}|${column.name}|${targetTable}|${column.name}`;
+                if (relationKeySet.has(key)) continue;
+
+                relations.push({
+                  from: `${table.name}.${column.name}`,
+                  to: `${targetTable}.${column.name}`,
+                  fromTable: table.name,
+                  toTable: targetTable,
+                  fromColumn: column.name,
+                  toColumn: column.name,
+                  isInferred: true
+                });
+                relationKeySet.add(key);
+              }
+            }
+          }
+        }
+      }
+
+      return {
+        tables: tablesWithColumns,
+        relations
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+}