@dbstudio/cli 0.1.7

package/src/drivers/sqlite.ts

@@ -0,0 +1,206 @@
+import { Database } from "bun:sqlite";
+import fs from "node:fs";
+import type {
+	ColumnInfo,
+	DatabaseConfig,
+	QueryResult,
+	TableInfo,
+} from "@dbstudio/types";
+import type { DatabaseDriver } from "./index";
+
+export class SQLiteDriver implements DatabaseDriver {
+	private db: Database | null = null;
+	private config: DatabaseConfig;
+
+	constructor(config: DatabaseConfig) {
+		this.config = config;
+	}
+
+	async connect(): Promise<void> {
+		if (!this.config.filepath) {
+			throw new Error("SQLite requires filepath");
+		}
+
+		if (!fs.existsSync(this.config.filepath)) {
+			throw new Error(`Database file not found: ${this.config.filepath}`);
+		}
+
+		this.db = new Database(this.config.filepath);
+	}
+
+	async disconnect(): Promise<void> {
+		if (this.db) {
+			this.db.close();
+			this.db = null;
+		}
+	}
+
+	async query(sql: string, params?: unknown[]): Promise<QueryResult> {
+		if (!this.db) throw new Error("Not connected");
+
+		const start = Date.now();
+		const isSelect = sql.trim().toUpperCase().startsWith("SELECT");
+
+		let result: QueryResult;
+
+		if (isSelect) {
+			const stmt = this.db.prepare(sql);
+			const rows = params ? stmt.all(...(params as any[])) : stmt.all();
+			result = {
+				columns: rows.length > 0 ? Object.keys(rows[0] as object) : [],
+				rows: rows as Record<string, unknown>[],
+				rowCount: rows.length,
+				executionTimeMs: Date.now() - start,
+			};
+		} else {
+			const stmt = this.db.prepare(sql);
+			const info = params ? stmt.run(...(params as any[])) : stmt.run();
+			result = {
+				columns: [],
+				rows: [],
+				rowCount: 0,
+				affectedRows: info.changes,
+				executionTimeMs: Date.now() - start,
+			};
+		}
+
+		return result;
+	}
+
+	async getTables(): Promise<TableInfo[]> {
+		if (!this.db) throw new Error("Not connected");
+
+		const rows = this.db
+			.prepare(
+				`SELECT name FROM sqlite_master 
+         WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`,
+			)
+			.all() as { name: string }[];
+
+		const tables: TableInfo[] = [];
+		for (const row of rows) {
+			try {
+				const tableInfo = await this.getTableSchema(row.name);
+				tables.push(tableInfo);
+			} catch (error) {
+				console.error(`Failed to get schema for table ${row.name}:`, error);
+				// Continue with other tables
+			}
+		}
+
+		return tables;
+	}
+
+	async getTableSchema(table: string): Promise<TableInfo> {
+		if (!this.db) throw new Error("Not connected");
+
+		const columnsRows = this.db
+			.prepare(`PRAGMA table_info("${table}")`)
+			.all() as {
+			name: string;
+			type: string;
+			notnull: number;
+			dflt_value: string | null;
+			pk: number;
+		}[];
+
+		const columns: ColumnInfo[] = columnsRows.map((row) => ({
+			name: row.name,
+			type: row.type,
+			nullable: row.notnull === 0,
+			defaultValue: row.dflt_value ?? undefined,
+			isPrimaryKey: row.pk === 1,
+			isForeignKey: false,
+		}));
+
+		const countRow = this.db
+			.prepare(`SELECT COUNT(*) as count FROM "${table}"`)
+			.get() as {
+			count: number;
+		};
+
+		// Get indexes
+		const indexesRows = this.db
+			.prepare(`PRAGMA index_list("${table}")`)
+			.all() as {
+			name: string;
+			unique: number;
+		}[];
+
+		const indexes = await Promise.all(
+			indexesRows.map(async (idx) => {
+				const info = this.db!.prepare(
+					`PRAGMA index_info("${idx.name}")`,
+				).all() as {
+					name: string;
+				}[];
+				return {
+					name: idx.name,
+					unique: idx.unique === 1,
+					columns: info.map((i) => i.name),
+				};
+			}),
+		);
+
+		// Get foreign keys for relations
+		const fkRows = this.db
+			.prepare(`PRAGMA foreign_key_list("${table}")`)
+			.all() as {
+			table: string;
+			from: string;
+			to: string;
+		}[];
+
+		const relations = fkRows.map((fk) => ({
+			name: `${table}_${fk.from}_fk`,
+			type: "belongsTo" as const,
+			fromTable: table,
+			fromColumn: fk.from,
+			toTable: fk.table,
+			toColumn: fk.to,
+		}));
+
+		return {
+			name: table,
+			schema: "main",
+			columns,
+			rowCount: countRow.count,
+			indexes,
+			relations,
+		};
+	}
+
+	async insertRow(
+		table: string,
+		data: Record<string, unknown>,
+	): Promise<QueryResult> {
+		if (!this.db) 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.db) 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/index.ts

@@ -0,0 +1,28 @@
+import "dotenv/config";
+import chalk from "chalk";
+import { program } from "commander";
+import { connectCommand } from "./commands/connect";
+import { disconnectCommand } from "./commands/disconnect";
+import { statusCommand } from "./commands/status";
+
+const logo = `
+${chalk.green("╔══════════════════════════════════════╗")}
+${chalk.green("║")}  ${chalk.bold.white("DBStudio")} ${chalk.gray("CLI Agent")}               ${chalk.green("║")}
+${chalk.green("║")}  ${chalk.gray("Connect your database to the cloud")}  ${chalk.green("║")}
+${chalk.green("╚══════════════════════════════════════╝")}
+`;
+
+program
+	.name("dbstudio")
+	.description("DBStudio CLI - Connect local databases to DBStudio cloud")
+	.version("0.1.0")
+	.hook("preAction", () => {
+		console.log(logo);
+	});
+
+// Register commands
+program.addCommand(connectCommand);
+program.addCommand(statusCommand);
+program.addCommand(disconnectCommand);
+
+program.parse(process.argv);

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"declaration": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+	entry: ["src/index.ts"],
+	format: ["esm"],
+	clean: true,
+	dts: true,
+	target: "node20",
+	banner: { js: "#!/usr/bin/env bun" },
+	external: ["bun:sqlite"],
+});