nikcli 0.0.6

package/src/cli/cmd/tui/component/table-db/db/db-connection.ts

@@ -0,0 +1,223 @@
+import type { DBSchema, DBTable, DBColumn, TablePreview, QueryResult } from "./types"
+import { detectDBType } from "./types"
+
+export class DBConnection {
+  private _path: string
+  private _dbType: ReturnType<typeof detectDBType>
+  private _db: any = null
+
+  constructor(path: string) {
+    this._path = path
+    this._dbType = detectDBType(path)
+  }
+
+  get type() { return this._dbType }
+  get path() { return this._path }
+
+  private _getDb(): any {
+    if (!this._db) {
+      const bunSqlite = require("bun:sqlite")
+      this._db = new bunSqlite.Database(this._path)
+    }
+    return this._db
+  }
+
+  getSchema(): DBSchema {
+    return this._getSqliteSchema()
+  }
+
+  private _getSqliteSchema(): DBSchema {
+    const tables = this._getSqliteTables()
+    const views = this._getSqliteViews()
+    const indexes = this._getSqliteIndexes()
+    return { tables, views, indexes }
+  }
+
+  private _getSqliteTables(): DBTable[] {
+    const db = this._getDb()
+    const tables: DBTable[] = []
+
+    try {
+      const sqliteMaster = db.prepare(`
+        SELECT name, sql FROM sqlite_master 
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `).all()
+
+      for (const row of sqliteMaster) {
+        const tableName = row.name
+        const columnsInfo = this._getTableInfo(tableName)
+        const rowCount = this._getRowCount(tableName)
+
+        tables.push({
+          name: tableName,
+          columns: columnsInfo,
+          primaryKey: columnsInfo.filter((c: DBColumn) => c.primaryKey).map((c: DBColumn) => c.name),
+          foreignKeys: this._getForeignKeys(tableName),
+          rowCount,
+          sql: row.sql ?? undefined,
+        })
+      }
+    } catch {
+      return []
+    }
+
+    return tables
+  }
+
+  private _getSqliteViews(): Array<{ name: string; sql: string }> {
+    const db = this._getDb()
+    try {
+      const views = db.prepare(`
+        SELECT name, sql FROM sqlite_master 
+        WHERE type='view'
+        ORDER BY name
+      `).all()
+
+      return views
+        .filter((v: any): v is { name: string; sql: string } => v.sql !== null)
+        .map((v: any) => ({ name: v.name, sql: v.sql }))
+    } catch {
+      return []
+    }
+  }
+
+  private _getSqliteIndexes(): Array<{ name: string; tableName: string; columns: string[]; unique: boolean }> {
+    const db = this._getDb()
+    try {
+      const indexes = db.prepare(`
+        SELECT name, tbl_name, sql FROM sqlite_master 
+        WHERE type='index' AND name NOT LIKE 'sqlite_%autoindex_%'
+      `).all()
+
+      return indexes.map((idx: any) => ({
+        name: idx.name,
+        tableName: idx.tbl_name,
+        columns: this._parseIndexColumns(idx.name),
+        unique: idx.sql?.toUpperCase().includes("UNIQUE") ?? false,
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  private _parseIndexColumns(indexName: string): string[] {
+    const db = this._getDb()
+    try {
+      const info = db.prepare(`PRAGMA index_info('${indexName}')`).all()
+      return info.map((c: any) => c.name)
+    } catch {
+      return []
+    }
+  }
+
+  private _getTableInfo(tableName: string): DBColumn[] {
+    const db = this._getDb()
+    const info = db.prepare(`PRAGMA table_info('${tableName}')`).all()
+
+    return info.map((col: any) => ({
+      name: col.name,
+      type: col.type || "TEXT",
+      notNull: col.notnull > 0,
+      defaultValue: col.dflt_value ?? undefined,
+      primaryKey: col.pk > 0,
+    }))
+  }
+
+  private _getForeignKeys(tableName: string): Array<{
+    table: string
+    column: string
+    referencedTable: string
+    referencedColumn: string
+    onDelete: "CASCADE" | "RESTRICT" | "SET NULL" | "NO ACTION"
+  }> {
+    const db = this._getDb()
+    try {
+      const fkInfo = db.prepare(`PRAGMA foreign_key_list('${tableName}')`).all()
+
+      return fkInfo.map((fk: any) => ({
+        table: tableName,
+        column: fk.from,
+        referencedTable: fk.table,
+        referencedColumn: fk.to,
+        onDelete: (fk.on_delete?.toUpperCase() as "CASCADE" | "RESTRICT" | "SET NULL" | "NO ACTION") || "NO ACTION",
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  private _getRowCount(tableName: string): number {
+    const db = this._getDb()
+    const result = db.prepare(`SELECT COUNT(*) as count FROM '${tableName}'`).get()
+    return result?.count ?? 0
+  }
+
+  getTablePreview(tableName: string, limit: number = 10): TablePreview {
+    const db = this._getDb()
+    const schema = this.getSchema()
+    const table = schema.tables.find((t) => t.name === tableName)
+
+    if (!table) {
+      return { tableName, columns: [], sampleData: [], rowCount: 0 }
+    }
+
+    const data = db.prepare(`SELECT * FROM '${tableName}' LIMIT ${limit}`).all()
+
+    return {
+      tableName,
+      columns: table.columns,
+      sampleData: data as any[],
+      rowCount: table.rowCount ?? 0,
+    }
+  }
+
+  executeQuery(sql: string): QueryResult {
+    const db = this._getDb()
+    const startTime = Date.now()
+
+    try {
+      const isSelect = sql.trim().toUpperCase().startsWith("SELECT")
+
+      if (isSelect) {
+        const result = db.prepare(sql).all()
+        const columns = result.length > 0 ? Object.keys(result[0]) : []
+
+        return {
+          columns,
+          rows: result as any[],
+          rowCount: result.length,
+          executionTime: Date.now() - startTime,
+        }
+      } else {
+        db.prepare(sql).run()
+        return {
+          columns: ["changes"],
+          rows: [{ changes: 0 }],
+          rowCount: 1,
+          executionTime: Date.now() - startTime,
+        }
+      }
+    } catch (error) {
+      throw new Error(`Query failed: ${error}`)
+    }
+  }
+
+  close(): void {
+    if (this._db) {
+      this._db.close()
+      this._db = null
+    }
+  }
+
+  static testConnection(path: string): boolean {
+    try {
+      const bunSqlite = require("bun:sqlite")
+      const db = new bunSqlite.Database(path)
+      db.close()
+      return true
+    } catch {
+      return false
+    }
+  }
+}

package/src/cli/cmd/tui/component/table-db/db/db-preview.ts

@@ -0,0 +1,202 @@
+import { DBConnection } from "./db-connection"
+import type { DBSchema, TablePreview, TableChange, DBColumn } from "./types"
+
+export class DBPreviewGenerator {
+  private _connection: DBConnection | null = null
+
+  constructor(connection: DBConnection) {
+    this._connection = connection
+  }
+
+  generateSchemaPreview(): TablePreview[] {
+    if (!this._connection) {
+      return []
+    }
+
+    try {
+      const schema = this._connection.getSchema()
+      return schema.tables.map((table) => ({
+        tableName: table.name,
+        columns: table.columns,
+        sampleData: [],
+        rowCount: table.rowCount || 0,
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  generateTablePreviews(limit: number = 10): TablePreview[] {
+    if (!this._connection) {
+      return []
+    }
+
+    try {
+      const schema = this._connection.getSchema()
+      return schema.tables.map((table) => {
+        const preview = this._connection!.getTablePreview(table.name, limit)
+        return preview
+      })
+    } catch {
+      return []
+    }
+  }
+
+  generateSchemaDiff(oldSchema: DBSchema, newSchema: DBSchema): TableChange[] {
+    const changes: TableChange[] = []
+
+    for (const newTable of newSchema.tables) {
+      const oldTable = oldSchema.tables.find((t) => t.name === newTable.name)
+      if (!oldTable) {
+        changes.push({
+          type: "add_table",
+          tableName: newTable.name,
+          newDefinition: {
+            name: newTable.name,
+            type: "TABLE" as const,
+            notNull: false,
+            primaryKey: false,
+          },
+        })
+      }
+    }
+
+    for (const oldTable of oldSchema.tables) {
+      const newTable = newSchema.tables.find((t) => t.name === oldTable.name)
+      if (!newTable) {
+        changes.push({
+          type: "drop_table",
+          tableName: oldTable.name,
+          oldDefinition: {
+            name: oldTable.name,
+            type: "TABLE" as const,
+            notNull: false,
+            primaryKey: false,
+          },
+        })
+      }
+    }
+
+    for (const newTable of newSchema.tables) {
+      const oldTable = oldSchema.tables.find((t) => t.name === newTable.name)
+      if (oldTable) {
+        for (const newCol of newTable.columns) {
+          const oldCol = oldTable.columns.find((c) => c.name === newCol.name)
+          if (!oldCol) {
+            changes.push({
+              type: "add_column",
+              tableName: newTable.name,
+              columnName: newCol.name,
+              newDefinition: newCol,
+            })
+          }
+        }
+
+        for (const oldCol of oldTable.columns) {
+          const newCol = newTable.columns.find((c) => c.name === oldCol.name)
+          if (!newCol) {
+            changes.push({
+              type: "drop_column",
+              tableName: newTable.name,
+              columnName: oldCol.name,
+              oldDefinition: oldCol,
+            })
+          }
+        }
+      }
+    }
+
+    return changes
+  }
+
+  generateSQLPreview(changes: TableChange[]): string {
+    const statements: string[] = []
+
+    for (const change of changes) {
+      switch (change.type) {
+        case "add_table":
+          if ((change.newDefinition as unknown as { sql?: string })?.sql) {
+            statements.push((change.newDefinition as unknown as { sql: string }).sql)
+          } else {
+            const columns =
+              (
+                change.newDefinition as unknown as { columns?: Array<{ name: string; type: string; notNull: boolean }> }
+              )?.columns
+                ?.map((c) => `${c.name} ${c.type}${c.notNull ? " NOT NULL" : ""}`)
+                .join(", ") ?? ""
+            statements.push(`CREATE TABLE ${change.tableName} (${columns});`)
+          }
+          break
+
+        case "drop_table":
+          statements.push(`DROP TABLE IF EXISTS ${change.tableName};`)
+          break
+
+        case "add_column":
+          if (change.newDefinition) {
+            const { name, type, notNull, defaultValue } = change.newDefinition
+            const parts = [`${name} ${type}`]
+            if (notNull) parts.push("NOT NULL")
+            if (defaultValue !== undefined) parts.push(`DEFAULT ${defaultValue}`)
+            statements.push(`ALTER TABLE ${change.tableName} ADD COLUMN ${parts.join(" ")};`)
+          }
+          break
+
+        case "drop_column":
+          statements.push(`-- Cannot drop column directly in SQLite`)
+          statements.push(`-- Table ${change.tableName} column ${change.columnName} would be dropped`)
+          break
+
+        case "modify_column":
+          statements.push(`-- Column modification requires table recreation`)
+          statements.push(`-- ${change.tableName}.${change.columnName}`)
+          break
+      }
+    }
+
+    return statements.join("\n")
+  }
+
+  previewFromSQL(sql: string): TablePreview | null {
+    if (!this._connection) {
+      return null
+    }
+
+    try {
+      const result = this._connection.executeQuery(sql)
+
+      if (result.columns.length === 0) {
+        return null
+      }
+
+      const columns: Array<{ name: string; type: string; notNull: boolean; primaryKey: boolean }> = result.columns.map(
+        (name) => ({
+          name,
+          type: "TEXT",
+          notNull: false,
+          primaryKey: false,
+        }),
+      )
+
+      return {
+        tableName: "Query Result",
+        columns,
+        sampleData: result.rows.slice(0, 10),
+        rowCount: result.rowCount,
+      }
+    } catch {
+      return null
+    }
+  }
+
+  async previewFromFile(filePath: string): Promise<TablePreview[]> {
+    const connection = new DBConnection(filePath)
+
+    try {
+      const schema = connection.getSchema()
+      return schema.tables.map((table) => connection.getTablePreview(table.name, 10))
+    } catch {
+      return []
+    }
+  }
+}

package/src/cli/cmd/tui/component/table-db/db/factory.ts

@@ -0,0 +1,77 @@
+import type { IDBConnection, ConnectionConfig } from "./connections"
+import { parseConnectionString } from "./connections"
+import { SQLiteConnection } from "./sqlite-connection"
+import { PostgresConnection } from "./postgres-connection"
+import { MySQLConnection } from "./mysql-connection"
+
+export class ConnectionFactory {
+  private static _instances = new Map<string, IDBConnection>()
+
+  static async create(config: string | ConnectionConfig): Promise<IDBConnection> {
+    const resolvedConfig = typeof config === "string" ? parseConnectionString(config) : config
+
+    const key = this._getConnectionKey(resolvedConfig)
+    if (this._instances.has(key)) {
+      const existing = this._instances.get(key)!
+      if (existing.connected) {
+        return existing
+      }
+    }
+
+    let connection: IDBConnection
+
+    switch (resolvedConfig.type) {
+      case "postgres":
+        connection = new PostgresConnection(resolvedConfig)
+        break
+      case "mysql":
+        connection = new MySQLConnection(resolvedConfig)
+        break
+      case "sqlite":
+      default:
+        connection = new SQLiteConnection(resolvedConfig)
+        break
+    }
+
+    this._instances.set(key, connection)
+    return connection
+  }
+
+  private static _getConnectionKey(config: ConnectionConfig): string {
+    if (config.path) return `sqlite:${config.path}`
+    return `${config.type}://${config.host}:${config.port}/${config.database}`
+  }
+
+  static async get(key: string): Promise<IDBConnection | undefined> {
+    return this._instances.get(key)
+  }
+
+  static async close(key: string): Promise<void> {
+    const conn = this._instances.get(key)
+    if (conn) {
+      conn.close()
+      this._instances.delete(key)
+    }
+  }
+
+  static async closeAll(): Promise<void> {
+    for (const conn of this._instances.values()) {
+      conn.close()
+    }
+    this._instances.clear()
+  }
+}
+
+export function createConnection(connStr: string): Promise<IDBConnection> {
+  return ConnectionFactory.create(connStr)
+}
+
+export { parseConnectionString }
+
+export function getConnection(key: string): Promise<IDBConnection | undefined> {
+  return ConnectionFactory.get(key)
+}
+
+export function closeConnection(key: string): Promise<void> {
+  return ConnectionFactory.close(key)
+}

package/src/cli/cmd/tui/component/table-db/db/index.ts

@@ -0,0 +1,9 @@
+export * from "./types"
+export { DBConnection } from "./db-connection"
+export { DBPreviewGenerator } from "./db-preview"
+export { detectDBType, DB_EXTENSIONS } from "./types"
+export type { IDBConnection, ConnectionConfig } from "./connections"
+export { SQLiteConnection } from "./sqlite-connection"
+export { PostgresConnection } from "./postgres-connection"
+export { MySQLConnection } from "./mysql-connection"
+export { ConnectionFactory, createConnection, getConnection, closeConnection, parseConnectionString } from "./factory"