@dbstudio/cli 0.1.7

package/src/drivers/libsql.ts

@@ -0,0 +1,189 @@
+import type {
+	ColumnInfo,
+	DatabaseConfig,
+	QueryResult,
+	TableInfo,
+} from "@dbstudio/types";
+import { type Client, createClient } from "@libsql/client";
+import type { DatabaseDriver } from "./index";
+
+export class LibSQLDriver implements DatabaseDriver {
+	private client: Client | null = null;
+	private config: DatabaseConfig;
+
+	constructor(config: DatabaseConfig) {
+		this.config = config;
+	}
+
+	async connect(): Promise<void> {
+		if (!this.config.url) {
+			throw new Error("libSQL requires a connection URL");
+		}
+
+		this.client = createClient({
+			url: this.config.url,
+			authToken: this.config.authToken,
+		});
+
+		// Test connection
+		await this.client.execute("SELECT 1");
+	}
+
+	async disconnect(): Promise<void> {
+		if (this.client) {
+			this.client.close();
+			this.client = null;
+		}
+	}
+
+	async query(sql: string, params?: unknown[]): Promise<QueryResult> {
+		if (!this.client) throw new Error("Not connected");
+
+		const start = Date.now();
+		const result = await this.client.execute({
+			sql,
+			args: (params as any[]) || [],
+		});
+		const executionTimeMs = Date.now() - start;
+
+		return {
+			columns: result.columns,
+			rows: result.rows.map((row) => {
+				const obj: Record<string, unknown> = {};
+				result.columns.forEach((col, i) => {
+					obj[col] = row[i];
+				});
+				return obj;
+			}),
+			rowCount: result.rows.length,
+			affectedRows: result.rowsAffected,
+			executionTimeMs,
+		};
+	}
+
+	async getTables(): Promise<TableInfo[]> {
+		if (!this.client) throw new Error("Not connected");
+
+		const result = await this.client.execute(
+			`SELECT name FROM sqlite_master 
+       WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+       ORDER BY name`,
+		);
+
+		const tables: TableInfo[] = [];
+		for (const row of result.rows) {
+			const tableName = row[0] as string;
+			try {
+				const tableInfo = await this.getTableSchema(tableName);
+				tables.push(tableInfo);
+			} catch (error) {
+				console.error(`Failed to get schema for table ${tableName}:`, error);
+			}
+		}
+
+		return tables;
+	}
+
+	async getTableSchema(table: string): Promise<TableInfo> {
+		if (!this.client) throw new Error("Not connected");
+
+		// Get columns
+		const columnsResult = await this.client.execute(
+			`PRAGMA table_info("${table}")`,
+		);
+		const columns: ColumnInfo[] = columnsResult.rows.map((row) => ({
+			name: row[1] as string,
+			type: row[2] as string,
+			nullable: (row[3] as number) === 0,
+			defaultValue: (row[4] as string) || undefined,
+			isPrimaryKey: (row[5] as number) === 1,
+			isForeignKey: false, // Will be updated by relations
+		}));
+
+		// Get row count
+		const countResult = await this.client.execute(
+			`SELECT COUNT(*) as count FROM "${table}"`,
+		);
+		const rowCount = countResult.rows[0][0] as number;
+
+		// Get indexes
+		const indexListResult = await this.client.execute(
+			`PRAGMA index_list("${table}")`,
+		);
+		const indexes = await Promise.all(
+			indexListResult.rows.map(async (row) => {
+				const indexName = row[1] as string;
+				const isUnique = (row[2] as number) === 1;
+				const indexInfoResult = await this.client!.execute(
+					`PRAGMA index_info("${indexName}")`,
+				);
+				return {
+					name: indexName,
+					unique: isUnique,
+					columns: indexInfoResult.rows.map((r) => r[2] as string),
+				};
+			}),
+		);
+
+		// Get foreign keys for relations
+		const fkListResult = await this.client.execute(
+			`PRAGMA foreign_key_list("${table}")`,
+		);
+		const relations = fkListResult.rows.map((row) => ({
+			name: `${table}_${row[3] as string}_fk`,
+			type: "belongsTo" as const,
+			fromTable: table,
+			fromColumn: row[3] as string,
+			toTable: row[2] as string,
+			toColumn: row[4] as string,
+		}));
+
+		// Mark foreign key columns
+		for (const rel of relations) {
+			const col = columns.find((c) => c.name === rel.fromColumn);
+			if (col) col.isForeignKey = true;
+		}
+
+		return {
+			name: table,
+			schema: "main",
+			columns,
+			rowCount,
+			indexes,
+			relations,
+		};
+	}
+
+	async insertRow(
+		table: string,
+		data: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.client) throw new Error("Not connected");
+
+		const columns = Object.keys(data);
+		const values = Object.values(data);
+		const placeholders = values.map(() => "?").join(", ");
+		const sql = `INSERT INTO "${table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+
+		return this.query(sql, values);
+	}
+
+	async updateRow(
+		table: string,
+		data: Record<string, unknown>,
+		where: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.client) throw new Error("Not connected");
+
+		const setClauses = Object.keys(data)
+			.map((c) => `"${c}" = ?`)
+			.join(", ");
+		const whereClauses = Object.keys(where)
+			.map((c) => `"${c}" = ?`)
+			.join(" AND ");
+		const values = [...Object.values(data), ...Object.values(where)];
+		const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+
+		return this.query(sql, values);
+	}
+}

package/src/drivers/mysql.ts

@@ -0,0 +1,199 @@
+import type {
+	ColumnInfo,
+	DatabaseConfig,
+	QueryResult,
+	TableInfo,
+} from "@dbstudio/types";
+import mysql from "mysql2/promise";
+import type { DatabaseDriver } from "./index";
+
+export class MySQLDriver implements DatabaseDriver {
+	private connection: mysql.Connection | null = null;
+	private config: DatabaseConfig;
+
+	constructor(config: DatabaseConfig) {
+		this.config = config;
+	}
+
+	async connect(): Promise<void> {
+		if (this.config.url) {
+			this.connection = await mysql.createConnection(this.config.url);
+		} else {
+			this.connection = await mysql.createConnection({
+				host: this.config.host,
+				port: this.config.port,
+				database: this.config.database,
+				user: this.config.username,
+				password: this.config.password,
+				ssl: this.config.ssl ? {} : undefined,
+			});
+		}
+	}
+
+	async disconnect(): Promise<void> {
+		if (this.connection) {
+			await this.connection.end();
+			this.connection = null;
+		}
+	}
+
+	async query(sql: string, params?: unknown[]): Promise<QueryResult> {
+		if (!this.connection) throw new Error("Not connected");
+
+		const start = Date.now();
+		const [rows, fields] = await this.connection.execute(sql, params);
+		const executionTimeMs = Date.now() - start;
+
+		const isResultSet = Array.isArray(rows);
+
+		return {
+			columns: fields ? (fields as mysql.FieldPacket[]).map((f) => f.name) : [],
+			rows: isResultSet ? (rows as Record<string, unknown>[]) : [],
+			rowCount: isResultSet ? rows.length : 0,
+			affectedRows: !isResultSet
+				? (rows as mysql.ResultSetHeader).affectedRows
+				: undefined,
+			executionTimeMs,
+		};
+	}
+
+	async getTables(schema?: string): Promise<TableInfo[]> {
+		if (!this.connection) throw new Error("Not connected");
+
+		const db = schema || this.config.database;
+		const [rows] = await this.connection.execute(
+			`SELECT table_name 
+       FROM information_schema.tables 
+       WHERE table_schema = ? AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,
+			[db],
+		);
+
+		const tables: TableInfo[] = [];
+		for (const row of rows as any[]) {
+			const tableInfo = await this.getTableSchema(
+				row.TABLE_NAME || row.table_name,
+				db,
+			);
+			tables.push(tableInfo);
+		}
+
+		return tables;
+	}
+
+	async getTableSchema(table: string, schema?: string): Promise<TableInfo> {
+		if (!this.connection) throw new Error("Not connected");
+
+		const db = schema || this.config.database;
+
+		const [columnsRows] = await this.connection.execute(
+			`SELECT 
+        COLUMN_NAME as column_name,
+        DATA_TYPE as data_type,
+        IS_NULLABLE as is_nullable,
+        COLUMN_DEFAULT as column_default,
+        COLUMN_KEY as column_key
+       FROM information_schema.columns
+       WHERE table_schema = ? AND table_name = ?
+       ORDER BY ordinal_position`,
+			[db, table],
+		);
+
+		const columns: ColumnInfo[] = (columnsRows as any[]).map((row) => ({
+			name: row.column_name,
+			type: row.data_type,
+			nullable: row.is_nullable === "YES",
+			defaultValue: row.column_default,
+			isPrimaryKey: row.column_key === "PRI",
+			isForeignKey: row.column_key === "MUL",
+		}));
+
+		const [countRows] = await this.connection.execute(
+			`SELECT COUNT(*) as count FROM \`${db}\`.\`${table}\``,
+		);
+
+		// Get indexes
+		const [indexesRows] = await this.connection.execute(
+			`SHOW INDEX FROM \`${table}\` FROM \`${db}\``,
+		);
+
+		const indexesMap = new Map<
+			string,
+			{ name: string; columns: string[]; unique: boolean }
+		>();
+		(indexesRows as any[]).forEach((row) => {
+			if (!indexesMap.has(row.Key_name)) {
+				indexesMap.set(row.Key_name, {
+					name: row.Key_name,
+					columns: [],
+					unique: row.Non_unique === 0,
+				});
+			}
+			indexesMap.get(row.Key_name)!.columns.push(row.Column_name);
+		});
+		const indexes = Array.from(indexesMap.values());
+
+		// Get relations
+		const [relationsRows] = await this.connection.execute(
+			`SELECT 
+        CONSTRAINT_NAME as constraint_name,
+        COLUMN_NAME as column_name,
+        REFERENCED_TABLE_NAME as referenced_table_name,
+        REFERENCED_COLUMN_NAME as referenced_column_name
+       FROM information_schema.KEY_COLUMN_USAGE
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND REFERENCED_TABLE_NAME IS NOT NULL`,
+			[db, table],
+		);
+
+		const relations = (relationsRows as any[]).map((row) => ({
+			name: row.constraint_name,
+			type: "belongsTo" as const,
+			fromTable: table,
+			fromColumn: row.column_name,
+			toTable: row.referenced_table_name,
+			toColumn: row.referenced_column_name,
+		}));
+
+		return {
+			name: table,
+			schema: db!,
+			columns,
+			rowCount: Number.parseInt((countRows as any[])[0].count, 10),
+			indexes,
+			relations,
+		};
+	}
+
+	async insertRow(
+		table: string,
+		data: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.connection) throw new Error("Not connected");
+
+		const columns = Object.keys(data);
+		const values = Object.values(data);
+		const placeholders = values.map(() => "?").join(", ");
+		const sql = `INSERT INTO \`${table}\` (${columns.map((c) => `\`${c}\``).join(", ")}) VALUES (${placeholders})`;
+
+		return this.query(sql, values);
+	}
+
+	async updateRow(
+		table: string,
+		data: Record<string, unknown>,
+		where: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.connection) throw new Error("Not connected");
+
+		const setClauses = Object.keys(data)
+			.map((c) => `\`${c}\` = ?`)
+			.join(", ");
+		const whereClauses = Object.keys(where)
+			.map((c) => `\`${c}\` = ?`)
+			.join(" AND ");
+		const values = [...Object.values(data), ...Object.values(where)];
+		const sql = `UPDATE \`${table}\` SET ${setClauses} WHERE ${whereClauses}`;
+
+		return this.query(sql, values);
+	}
+}

package/src/drivers/postgres.ts

@@ -0,0 +1,224 @@
+import type {
+	ColumnInfo,
+	DatabaseConfig,
+	QueryResult,
+	TableInfo,
+} from "@dbstudio/types";
+import pg from "pg";
+import type { DatabaseDriver } from "./index";
+
+const { Pool } = pg;
+
+export class PostgresDriver implements DatabaseDriver {
+	private pool: pg.Pool | null = null;
+	private config: DatabaseConfig;
+
+	constructor(config: DatabaseConfig) {
+		this.config = config;
+	}
+
+	async connect(): Promise<void> {
+		if (this.config.url) {
+			this.pool = new Pool({
+				connectionString: this.config.url,
+				ssl: this.config.ssl ? { rejectUnauthorized: false } : undefined,
+			});
+		} else {
+			this.pool = new Pool({
+				host: this.config.host,
+				port: this.config.port,
+				database: this.config.database,
+				user: this.config.username,
+				password: this.config.password || "",
+				ssl: this.config.ssl ? { rejectUnauthorized: false } : undefined,
+			});
+		}
+
+		// Test connection
+		const client = await this.pool.connect();
+		client.release();
+	}
+
+	async disconnect(): Promise<void> {
+		const pool = this.pool;
+		this.pool = null;
+		if (pool) {
+			await pool.end();
+		}
+	}
+
+	async query(sql: string, params?: unknown[]): Promise<QueryResult> {
+		if (!this.pool) throw new Error("Not connected");
+
+		const start = Date.now();
+		const result = await this.pool.query(sql, params);
+		const executionTimeMs = Date.now() - start;
+
+		return {
+			columns: result.fields.map((f) => f.name),
+			rows: result.rows,
+			rowCount: result.rows.length,
+			affectedRows: result.rowCount ?? undefined,
+			executionTimeMs,
+		};
+	}
+
+	async getTables(schema = "public"): Promise<TableInfo[]> {
+		if (!this.pool) throw new Error("Not connected");
+
+		const result = await this.pool.query(
+			`SELECT table_name 
+       FROM information_schema.tables 
+       WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,
+			[schema],
+		);
+
+		const tables: TableInfo[] = [];
+		for (const row of result.rows) {
+			const tableInfo = await this.getTableSchema(row.table_name, schema);
+			tables.push(tableInfo);
+		}
+
+		return tables;
+	}
+
+	async getTableSchema(table: string, schema = "public"): Promise<TableInfo> {
+		if (!this.pool) throw new Error("Not connected");
+
+		// Get columns
+		const columnsResult = await this.pool.query(
+			`SELECT 
+        column_name,
+        data_type,
+        is_nullable,
+        column_default
+       FROM information_schema.columns
+       WHERE table_schema = $1 AND table_name = $2
+       ORDER BY ordinal_position`,
+			[schema, table],
+		);
+
+		// Get constraints for this table's columns
+		const constraintsResult = await this.pool.query(
+			`SELECT 
+        ccu.column_name,
+        tc.constraint_type
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.constraint_column_usage ccu 
+         ON tc.constraint_name = ccu.constraint_name 
+         AND tc.table_schema = ccu.table_schema
+       WHERE tc.table_schema = $1 AND tc.table_name = $2`,
+			[schema, table],
+		);
+
+		const columnConstraints = new Map<string, string[]>();
+		for (const row of constraintsResult.rows) {
+			if (!columnConstraints.has(row.column_name)) {
+				columnConstraints.set(row.column_name, []);
+			}
+			columnConstraints.get(row.column_name)?.push(row.constraint_type);
+		}
+
+		const columns: ColumnInfo[] = columnsResult.rows.map((row) => {
+			const constraints = columnConstraints.get(row.column_name) || [];
+			return {
+				name: row.column_name,
+				type: row.data_type,
+				nullable: row.is_nullable === "YES",
+				defaultValue: row.column_default,
+				isPrimaryKey: constraints.includes("PRIMARY KEY"),
+				isForeignKey: constraints.includes("FOREIGN KEY"),
+			};
+		});
+
+		// Get indexes
+		const indexesResult = await this.pool.query(
+			`SELECT indexname, indexdef 
+       FROM pg_indexes 
+       WHERE schemaname = $1 AND tablename = $2`,
+			[schema, table],
+		);
+
+		const indexes = indexesResult.rows.map((row) => ({
+			name: row.indexname,
+			columns: [], // Parsing columns from indexdef is complex, leaving empty for now or need regex
+			unique: row.indexdef.includes("UNIQUE"),
+		}));
+
+		// Get relations
+		const relationsResult = await this.pool.query(
+			`SELECT
+        tc.constraint_name,
+        tc.constraint_type,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1 AND tc.table_name = $2`,
+			[schema, table],
+		);
+
+		const relations = relationsResult.rows.map((row) => ({
+			name: row.constraint_name,
+			type: "belongsTo" as const,
+			fromTable: table,
+			fromColumn: row.column_name,
+			toTable: row.foreign_table_name,
+			toColumn: row.foreign_column_name,
+		}));
+
+		// Get row count
+		const countResult = await this.pool.query(
+			`SELECT COUNT(*) as count FROM "${schema}"."${table}"`,
+		);
+
+		return {
+			name: table,
+			schema,
+			columns,
+			rowCount: Number.parseInt(countResult.rows[0].count, 10),
+			indexes,
+			relations,
+		};
+	}
+
+	async insertRow(
+		table: string,
+		data: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.pool) throw new Error("Not connected");
+
+		const columns = Object.keys(data);
+		const values = Object.values(data);
+		const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+		const sql = `INSERT INTO "${table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+
+		return this.query(sql, values);
+	}
+
+	async updateRow(
+		table: string,
+		data: Record<string, unknown>,
+		where: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.pool) throw new Error("Not connected");
+
+		const setClauses = Object.keys(data)
+			.map((c, i) => `"${c}" = $${i + 1}`)
+			.join(", ");
+		const whereClauses = Object.keys(where)
+			.map((c, i) => `"${c}" = $${Object.keys(data).length + i + 1}`)
+			.join(" AND ");
+		const values = [...Object.values(data), ...Object.values(where)];
+		const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+
+		return this.query(sql, values);
+	}
+}