spindb 0.31.0 → 0.31.1

package/README.md

@@ -305,6 +305,13 @@ spindb run mydb -c "SELECT * FROM users"        # Inline SQL
 spindb run mydb seed.js                         # JavaScript (MongoDB)
 spindb run mydb -c "SET foo bar"                # Redis command
 
+# Query with structured output
+spindb query mydb "SELECT * FROM users LIMIT 5" # Tabular output
+spindb query mydb "SELECT * FROM users" --json  # JSON for scripting
+spindb query mydb "users.find()" -d mydb        # MongoDB/FerretDB
+spindb query myredis "KEYS user:*"              # Redis/Valkey
+spindb query myqdrant "GET /collections"        # REST API engines
+
 # Get connection string
 spindb url mydb                                 # postgresql://postgres@localhost:5432/mydb
 spindb url mydb --copy                          # Copy to clipboard

package/cli/commands/query.ts

@@ -0,0 +1,238 @@
+import { Command } from 'commander'
+import { existsSync } from 'fs'
+import chalk from 'chalk'
+import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
+import { getEngine } from '../../engines'
+import { promptInstallDependencies } from '../ui/prompts'
+import { uiError, uiWarning } from '../ui/theme'
+import { getMissingDependencies } from '../../core/dependency-manager'
+import { Engine, isFileBasedEngine, type QueryResult } from '../../types'
+
+/**
+ * Format a QueryResult as a table for terminal output
+ */
+function formatTable(result: QueryResult): string {
+  if (result.columns.length === 0 || result.rows.length === 0) {
+    return '(0 rows)'
+  }
+
+  // Calculate column widths
+  const widths: number[] = result.columns.map((col) => col.length)
+
+  for (const row of result.rows) {
+    for (let i = 0; i < result.columns.length; i++) {
+      const col = result.columns[i]
+      const value = formatValue(row[col])
+      widths[i] = Math.max(widths[i], value.length)
+    }
+  }
+
+  // Build header
+  const header = result.columns
+    .map((col, i) => col.padEnd(widths[i]))
+    .join(' | ')
+
+  // Build separator
+  const separator = widths.map((w) => '-'.repeat(w)).join('-+-')
+
+  // Build rows
+  const rows = result.rows.map((row) =>
+    result.columns
+      .map((col, i) => formatValue(row[col]).padEnd(widths[i]))
+      .join(' | '),
+  )
+
+  // Combine
+  const lines = [header, separator, ...rows]
+
+  // Add row count
+  const countMsg =
+    result.rowCount === 1 ? '(1 row)' : `(${result.rowCount} rows)`
+  lines.push('')
+  lines.push(countMsg)
+
+  return lines.join('\n')
+}
+
+/**
+ * Format a value for display
+ */
+function formatValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return 'NULL'
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value)
+  }
+  return String(value)
+}
+
+export const queryCommand = new Command('query')
+  .description('Execute a query and return results')
+  .argument('<name>', 'Container name')
+  .argument('<query>', 'Query to execute')
+  .option('-d, --database <name>', 'Target database (defaults to primary)')
+  .option('--json', 'Output results as JSON')
+  .action(
+    async (
+      name: string,
+      query: string,
+      options: { database?: string; json?: boolean },
+    ) => {
+      try {
+        const containerName = name
+
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          if (options.json) {
+            console.log(
+              JSON.stringify({
+                error: `Container "${containerName}" not found`,
+              }),
+            )
+          } else {
+            console.error(uiError(`Container "${containerName}" not found`))
+          }
+          process.exit(1)
+        }
+
+        const { engine: engineName } = config
+
+        // File-based databases: check file exists instead of running status
+        if (isFileBasedEngine(engineName)) {
+          if (!existsSync(config.database)) {
+            if (options.json) {
+              console.log(
+                JSON.stringify({
+                  error: `Database file not found: ${config.database}`,
+                }),
+              )
+            } else {
+              console.error(
+                uiError(`Database file not found: ${config.database}`),
+              )
+            }
+            process.exit(1)
+          }
+        } else {
+          // Server databases need to be running
+          const running = await processManager.isRunning(containerName, {
+            engine: engineName,
+          })
+          if (!running) {
+            if (options.json) {
+              console.log(
+                JSON.stringify({
+                  error: `Container "${containerName}" is not running`,
+                }),
+              )
+            } else {
+              console.error(
+                uiError(
+                  `Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`,
+                ),
+              )
+            }
+            process.exit(1)
+          }
+        }
+
+        const engine = getEngine(engineName)
+
+        let missingDeps = await getMissingDependencies(engineName)
+        if (missingDeps.length > 0) {
+          if (options.json) {
+            console.log(
+              JSON.stringify({
+                error: `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+              }),
+            )
+            process.exit(1)
+          }
+
+          console.log(
+            uiWarning(
+              `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+            ),
+          )
+
+          const installed = await promptInstallDependencies(
+            missingDeps[0].binary,
+            engineName,
+          )
+
+          if (!installed) {
+            process.exit(1)
+          }
+
+          missingDeps = await getMissingDependencies(engineName)
+          if (missingDeps.length > 0) {
+            console.error(
+              uiError(
+                `Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+              ),
+            )
+            process.exit(1)
+          }
+
+          console.log(chalk.green('  ✓ All required tools are now available'))
+          console.log()
+        }
+
+        const database = options.database || config.database
+
+        // Execute the query
+        const result = await engine.executeQuery(config, query, { database })
+
+        // Output results
+        if (options.json) {
+          // JSON mode: output just the rows array
+          console.log(JSON.stringify(result.rows, null, 2))
+        } else {
+          // Table mode
+          console.log(formatTable(result))
+        }
+      } catch (error) {
+        const e = error as Error
+
+        // Map of tool patterns to their engines
+        const toolPatternToEngine: Record<string, Engine> = {
+          'psql not found': Engine.PostgreSQL,
+          'mysql not found': Engine.MySQL,
+          'mysql client not found': Engine.MySQL,
+          'redis-cli not found': Engine.Redis,
+          'mongosh not found': Engine.MongoDB,
+          'sqlite3 not found': Engine.SQLite,
+        }
+
+        const matchingPattern = Object.keys(toolPatternToEngine).find((p) =>
+          e.message.toLowerCase().includes(p.toLowerCase()),
+        )
+
+        if (matchingPattern && !options.json) {
+          const missingTool = matchingPattern
+            .replace(' not found', '')
+            .replace(' client', '')
+          const toolEngine = toolPatternToEngine[matchingPattern]
+          const installed = await promptInstallDependencies(
+            missingTool,
+            toolEngine,
+          )
+          if (installed) {
+            console.log(
+              chalk.yellow('  Please re-run your command to continue.'),
+            )
+          }
+          process.exit(1)
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ error: e.message }))
+        } else {
+          console.error(uiError(e.message))
+        }
+        process.exit(1)
+      }
+    },
+  )

package/cli/index.ts

@@ -30,6 +30,7 @@ import { databasesCommand } from './commands/databases'
 import { pullCommand } from './commands/pull'
 import { whichCommand } from './commands/which'
 import { exportCommand } from './commands/export'
+import { queryCommand } from './commands/query'
 import { updateManager } from '../core/update-manager'
 import { configManager } from '../core/config-manager'
 import { setCachedIconMode } from './constants'
@@ -142,6 +143,7 @@ export async function run(): Promise<void> {
   program.addCommand(pullCommand)
   program.addCommand(whichCommand)
   program.addCommand(exportCommand)
+  program.addCommand(queryCommand)
 
   if (process.argv.length <= 2) {
     // Only show update notification in interactive menu mode (once at startup)