sql-kite 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sql-kite",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "SQL-Kite CLI — Local-first SQLite workspace with branches, migrations and snapshots.",
   "type": "module",
   "preferGlobal": true,
@@ -9,14 +9,16 @@
   },
   "scripts": {
     "dev": "node bin/sql-kite.js",
-    "start": "node bin/sql-kite.js"
+    "start": "node bin/sql-kite.js",
+    "prepublishOnly": "node scripts/prepare-publish.js"
   },
   "author": "D Krishna",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/Ananta-V/sql-kite"
-  },  "homepage": "https://github.com/Ananta-V/sql-kite#readme",
+  },
+  "homepage": "https://github.com/Ananta-V/sql-kite#readme",
   "bugs": {
     "url": "https://github.com/Ananta-V/sql-kite/issues"
   },
@@ -36,14 +38,20 @@
   "files": [
     "bin/",
     "src/",
+    "server/",
+    "studio-out/",
     "README.md"
   ],
   "dependencies": {
+    "@fastify/cors": "^10.0.1",
+    "@fastify/static": "^8.0.2",
     "better-sqlite3": "^9.2.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
+    "fastify": "^5.7.4",
     "find-free-port": "^2.0.0",
     "inquirer": "^9.2.12",
+    "nanoid": "^5.0.4",
     "open": "^10.0.3",
     "ora": "^8.0.1"
   }

package/server/db/connections.js

@@ -0,0 +1,114 @@
+import Database from 'better-sqlite3';
+import { join } from 'path';
+
+const connections = new Map();
+
+/**
+ * Get the current active branch for a project
+ */
+export function getCurrentBranch(projectPath) {
+  try {
+    const metaDb = getMetaDb(projectPath);
+    const result = metaDb.prepare(`
+      SELECT value FROM settings WHERE key = 'current_branch'
+    `).get();
+
+    return result ? result.value : 'main';
+  } catch (error) {
+    console.error('Error getting current branch:', error.message);
+    return 'main'; // Fallback to main
+  }
+}
+
+/**
+ * Get user database for current branch
+ */
+export function getUserDb(projectPath, branchName = null) {
+  const branch = branchName || getCurrentBranch(projectPath);
+  const key = `user-${projectPath}-${branch}`;
+
+  if (!connections.has(key)) {
+    const metaDb = getMetaDb(projectPath);
+
+    // Get the DB file for this branch
+    const branchInfo = metaDb.prepare(`
+      SELECT db_file FROM branches WHERE name = ?
+    `).get(branch);
+
+    if (!branchInfo) {
+      throw new Error(`Branch "${branch}" does not exist`);
+    }
+
+    const dbPath = join(projectPath, branchInfo.db_file);
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    connections.set(key, db);
+  }
+
+  return connections.get(key);
+}
+
+export function getMetaDb(projectPath) {
+  const key = `meta-${projectPath}`;
+
+  if (!connections.has(key)) {
+    const dbPath = join(projectPath, '.studio', 'meta.db');
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    connections.set(key, db);
+  }
+
+  return connections.get(key);
+}
+
+/**
+ * Close and remove connection for a specific branch
+ * Used when switching branches
+ */
+export function closeBranchConnection(projectPath, branchName) {
+  const key = `user-${projectPath}-${branchName}`;
+
+  if (connections.has(key)) {
+    const db = connections.get(key);
+    db.close();
+    connections.delete(key);
+  }
+}
+
+/**
+ * Get a read-only user database connection for compare mode
+ */
+export function getReadOnlyUserDb(projectPath, branchName) {
+  const branch = branchName || getCurrentBranch(projectPath);
+  const key = `readonly-${projectPath}-${branch}`;
+
+  if (!connections.has(key)) {
+    const metaDb = getMetaDb(projectPath);
+
+    const branchInfo = metaDb.prepare(`
+      SELECT db_file FROM branches WHERE name = ?
+    `).get(branch);
+
+    if (!branchInfo) {
+      throw new Error(`Branch "${branch}" does not exist`);
+    }
+
+    const dbPath = join(projectPath, branchInfo.db_file);
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    db.pragma('query_only = ON');
+    db.pragma('busy_timeout = 2000');
+    connections.set(key, db);
+  }
+
+  return connections.get(key);
+}
+
+export function closeReadOnlyBranchConnection(projectPath, branchName) {
+  const key = `readonly-${projectPath}-${branchName}`;
+
+  if (connections.has(key)) {
+    const db = connections.get(key);
+    db.close();
+    connections.delete(key);
+  }
+}

package/server/index.js

@@ -0,0 +1,214 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import fastifyStatic from '@fastify/static';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { createRequire } from 'module';
+
+import { getUserDb, getMetaDb, getCurrentBranch } from './db/connections.js';
+import tablesRoutes from './routes/tables.js';
+import queryRoutes from './routes/query.js';
+import schemaRoutes from './routes/schema.js';
+import timelineRoutes from './routes/timeline.js';
+import migrationsRoutes from './routes/migrations.js';
+import snapshotsRoutes from './routes/snapshots.js';
+import branchesRoutes from './routes/branches.js';
+import importRoutes from './routes/import.js';
+import compareRoutes from './routes/compare.js';
+import exportRoutes from './routes/export.js';
+
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Import meta migration - works in both layouts:
+//   monorepo: packages/server/src/ -> ../../cli/src/utils/meta-migration.js
+//   npm:      sql-kite/server/     -> ../src/utils/meta-migration.js
+let migrateMetaDb;
+const metaMigrationPaths = [
+  join(__dirname, '..', 'src', 'utils', 'meta-migration.js'),       // npm layout
+  join(__dirname, '..', '..', 'cli', 'src', 'utils', 'meta-migration.js')  // monorepo
+];
+for (const p of metaMigrationPaths) {
+  if (existsSync(p)) {
+    const mod = await import(pathToFileURL(p).href);
+    migrateMetaDb = mod.migrateMetaDb;
+    break;
+  }
+}
+if (!migrateMetaDb) {
+  console.error('Could not find meta-migration.js. Tried:', metaMigrationPaths);
+  process.exit(1);
+}
+
+const PROJECT_NAME = process.env.PROJECT_NAME;
+const PROJECT_PATH = process.env.PROJECT_PATH;
+const PORT = parseInt(process.env.PORT || '3000');
+const IMPORT_MODE = process.env.IMPORT_MODE === 'true';
+
+if (!IMPORT_MODE && (!PROJECT_NAME || !PROJECT_PATH)) {
+  console.error('Missing required environment variables: PROJECT_NAME, PROJECT_PATH');
+  console.error('Or set IMPORT_MODE=true to run in import-only mode');
+  process.exit(1);
+}
+
+// Run meta database migration before starting server (skip in import mode)
+if (!IMPORT_MODE) {
+  const metaDbPath = join(PROJECT_PATH, '.studio', 'meta.db');
+  try {
+    migrateMetaDb(metaDbPath);
+  } catch (error) {
+    console.error('Failed to migrate meta database:', error);
+    process.exit(1);
+  }
+}
+
+const fastify = Fastify({
+  logger: {
+    level: 'info'
+  }
+});
+
+// CORS - Restrict to localhost origins only for security
+// This prevents CSRF-style attacks from malicious websites
+// Uses a function to allow any localhost port dynamically
+await fastify.register(cors, {
+  origin: (origin, callback) => {
+    // Allow requests with no origin (same-origin, curl, Postman, etc.)
+    if (!origin) {
+      return callback(null, true);
+    }
+    
+    // Allow any localhost or 127.0.0.1 origin (any port)
+    const localhostPattern = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/;
+    if (localhostPattern.test(origin)) {
+      return callback(null, true);
+    }
+    
+    // Block all other origins
+    return callback(new Error('CORS not allowed'), false);
+  }
+});
+
+// Store project info in fastify instance (if not in import mode)
+if (!IMPORT_MODE) {
+  fastify.decorate('projectName', PROJECT_NAME);
+  fastify.decorate('projectPath', PROJECT_PATH);
+  // API always queries 'main' branch only - branches are for Studio development only
+  fastify.decorate('getUserDb', () => getUserDb(PROJECT_PATH, 'main'));
+  fastify.decorate('getMetaDb', () => getMetaDb(PROJECT_PATH));
+  fastify.decorate('getCurrentBranch', () => getCurrentBranch(PROJECT_PATH));
+}
+
+// API Routes
+fastify.register(importRoutes, { prefix: '/api/import' });
+
+// Project-specific routes (only in project mode)
+if (!IMPORT_MODE) {
+  fastify.register(branchesRoutes, { prefix: '/api/branches' });
+  fastify.register(tablesRoutes, { prefix: '/api/tables' });
+  fastify.register(queryRoutes, { prefix: '/api/query' });
+  fastify.register(schemaRoutes, { prefix: '/api/schema' });
+  fastify.register(timelineRoutes, { prefix: '/api/timeline' });
+  fastify.register(migrationsRoutes, { prefix: '/api/migrations' });
+  fastify.register(snapshotsRoutes, { prefix: '/api/snapshots' });
+  fastify.register(compareRoutes, { prefix: '/api/compare' });
+  fastify.register(exportRoutes, { prefix: '/api/export' });
+}
+
+// Project info endpoint (only in project mode)
+if (!IMPORT_MODE) {
+  fastify.get('/api/project', async (request, reply) => {
+    const configPath = join(PROJECT_PATH, 'config.json');
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    const currentBranch = getCurrentBranch(PROJECT_PATH);
+
+    return {
+      name: PROJECT_NAME,
+      path: PROJECT_PATH,
+      port: PORT,
+      currentBranch,
+      ...config
+    };
+  });
+} else {
+  // Import mode - minimal project info
+  fastify.get('/api/project', async (request, reply) => {
+    return {
+      name: 'Import Mode',
+      mode: 'import',
+      port: PORT
+    };
+  });
+}
+
+// Serve Studio static files - works in both layouts:
+//   monorepo: packages/server/src/ -> ../../studio/out
+//   npm:      sql-kite/server/     -> ../studio-out
+let studioPath = join(__dirname, '..', 'studio-out');  // npm layout
+if (!existsSync(studioPath)) {
+  studioPath = join(__dirname, '..', '..', 'studio', 'out');  // monorepo layout
+}
+
+console.log('Looking for Studio at:', studioPath);
+console.log('Studio exists:', existsSync(studioPath));
+
+if (!existsSync(studioPath)) {
+  console.error('\n❌ ERROR: Studio build not found!');
+  console.error('Please run: cd packages/studio && npm run build\n');
+  process.exit(1);
+}
+
+await fastify.register(fastifyStatic, {
+  root: studioPath,
+  prefix: '/',
+  decorateReply: false,
+  index: 'index.html'
+});
+
+// Fallback to index.html for client-side routing
+fastify.setNotFoundHandler((request, reply) => {
+  if (request.url.startsWith('/api')) {
+    reply.code(404).send({ error: 'API endpoint not found' });
+  } else {
+    reply.sendFile('index.html');
+  }
+});
+
+// Graceful shutdown
+const closeGracefully = async (signal) => {
+  console.log(`\nReceived ${signal}, closing gracefully...`);
+
+  try {
+    // Close database connections
+    const userDb = getUserDb(PROJECT_PATH);
+    const metaDb = getMetaDb(PROJECT_PATH);
+    userDb.close();
+    metaDb.close();
+
+    // Remove server info file
+    const serverInfoPath = join(PROJECT_PATH, '.studio', 'server.json');
+    if (existsSync(serverInfoPath)) {
+      unlinkSync(serverInfoPath);
+    }
+  } catch (e) {
+    console.error('Error during shutdown:', e);
+  }
+
+  await fastify.close();
+  process.exit(0);
+};
+
+process.on('SIGTERM', closeGracefully);
+process.on('SIGINT', closeGracefully);
+
+// Start server
+try {
+  await fastify.listen({ port: PORT, host: '0.0.0.0' });
+  console.log(`\n✓ Server started for project "${PROJECT_NAME}"`);
+  console.log(`  URL: http://localhost:${PORT}`);
+  console.log(`  Path: ${PROJECT_PATH}\n`);
+} catch (err) {
+  fastify.log.error(err);
+  process.exit(1);
+}