spindb 0.7.5 → 0.8.1

package/README.md

@@ -217,6 +217,7 @@ spindb create mydb --from "postgresql://user:pass@host:5432/production"
 | `--version`, `-v` | Engine version |
 | `--port`, `-p` | Port number |
 | `--database`, `-d` | Primary database name |
+| `--max-connections` | Maximum database connections (default: 200) |
 | `--from` | Restore from backup file or connection string |
 | `--no-start` | Create without starting |
 
@@ -332,12 +333,13 @@ spindb clone source-db new-db
 spindb start new-db
 ```
 
-#### `edit` - Rename or change port
+#### `edit` - Rename, change port, or edit database config
 
 ```bash
-spindb edit mydb --name newname   # Must be stopped
+spindb edit mydb --name newname              # Must be stopped
 spindb edit mydb --port 5433
-spindb edit mydb                  # Interactive mode
+spindb edit mydb --set-config max_connections=300   # PostgreSQL config
+spindb edit mydb                             # Interactive mode
 ```
 
 #### `logs` - View container logs

package/cli/commands/create.ts

@@ -51,6 +51,10 @@ export const createCommand = new Command('create')
   .option('-v, --version <version>', 'Database version')
   .option('-d, --database <database>', 'Database name')
   .option('-p, --port <port>', 'Port number')
+  .option(
+    '--max-connections <number>',
+    'Maximum number of database connections (default: 200)',
+  )
   .option('--no-start', 'Do not start the container after creation')
   .option(
     '--from <location>',
@@ -64,6 +68,7 @@ export const createCommand = new Command('create')
         version?: string
         database?: string
         port?: string
+        maxConnections?: string
         start: boolean
         from?: string
       },
@@ -256,6 +261,9 @@ export const createCommand = new Command('create')
         try {
           await dbEngine.initDataDir(containerName, version, {
             superuser: engineDefaults.superuser,
+            maxConnections: options.maxConnections
+              ? parseInt(options.maxConnections, 10)
+              : undefined,
           })
           initSpinner.succeed('Database cluster initialized')
         } catch (err) {

package/cli/commands/edit.ts

@@ -4,30 +4,45 @@ import inquirer from 'inquirer'
 import { containerManager } from '../../core/container-manager'
 import { processManager } from '../../core/process-manager'
 import { portManager } from '../../core/port-manager'
+import { getEngine } from '../../engines'
+import { paths } from '../../config/paths'
 import { promptContainerSelect } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
-import { error, warning, success } from '../ui/theme'
+import { error, warning, success, info } from '../ui/theme'
 
 function isValidName(name: string): boolean {
   return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)
 }
 
-async function promptEditAction(): Promise<'name' | 'port' | null> {
+/**
+ * Prompt for what to edit when no options provided
+ */
+async function promptEditAction(
+  engine: string,
+): Promise<'name' | 'port' | 'config' | null> {
+  const choices = [
+    { name: 'Rename container', value: 'name' },
+    { name: 'Change port', value: 'port' },
+  ]
+
+  // Only show config option for engines that support it
+  if (engine === 'postgresql') {
+    choices.push({ name: 'Edit database config (postgresql.conf)', value: 'config' })
+  }
+
+  choices.push({ name: chalk.gray('Cancel'), value: 'cancel' })
+
   const { action } = await inquirer.prompt<{ action: string }>([
     {
       type: 'list',
       name: 'action',
       message: 'What would you like to edit?',
-      choices: [
-        { name: 'Rename container', value: 'name' },
-        { name: 'Change port', value: 'port' },
-        { name: chalk.gray('Cancel'), value: 'cancel' },
-      ],
+      choices,
     },
   ])
 
   if (action === 'cancel') return null
-  return action as 'name' | 'port'
+  return action as 'name' | 'port' | 'config'
 }
 
 async function promptNewName(currentName: string): Promise<string | null> {
@@ -55,6 +70,74 @@ async function promptNewName(currentName: string): Promise<string | null> {
   return newName
 }
 
+// Common PostgreSQL config settings that users might want to edit
+const COMMON_PG_SETTINGS = [
+  { name: 'max_connections', description: 'Maximum concurrent connections', default: '200' },
+  { name: 'shared_buffers', description: 'Memory for shared buffers', default: '128MB' },
+  { name: 'work_mem', description: 'Memory per operation', default: '4MB' },
+  { name: 'maintenance_work_mem', description: 'Memory for maintenance ops', default: '64MB' },
+  { name: 'effective_cache_size', description: 'Planner cache size estimate', default: '4GB' },
+]
+
+/**
+ * Prompt for PostgreSQL config setting to edit
+ */
+async function promptConfigSetting(): Promise<{ key: string; value: string } | null> {
+  const choices = COMMON_PG_SETTINGS.map((s) => ({
+    name: `${s.name.padEnd(25)} ${chalk.gray(s.description)}`,
+    value: s.name,
+  }))
+  choices.push({ name: chalk.cyan('Custom setting...'), value: '__custom__' })
+  choices.push({ name: chalk.gray('Cancel'), value: '__cancel__' })
+
+  const { setting } = await inquirer.prompt<{ setting: string }>([
+    {
+      type: 'list',
+      name: 'setting',
+      message: 'Select setting to edit:',
+      choices,
+    },
+  ])
+
+  if (setting === '__cancel__') return null
+
+  let key = setting
+  if (setting === '__custom__') {
+    const { customKey } = await inquirer.prompt<{ customKey: string }>([
+      {
+        type: 'input',
+        name: 'customKey',
+        message: 'Setting name:',
+        validate: (input: string) => {
+          if (!input.trim()) return 'Setting name is required'
+          if (!/^[a-z_]+$/.test(input)) return 'Setting names are lowercase with underscores'
+          return true
+        },
+      },
+    ])
+    key = customKey
+  }
+
+  const defaultValue = COMMON_PG_SETTINGS.find((s) => s.name === key)?.default || ''
+  const { value } = await inquirer.prompt<{ value: string }>([
+    {
+      type: 'input',
+      name: 'value',
+      message: `Value for ${key}:`,
+      default: defaultValue,
+      validate: (input: string) => {
+        if (!input.trim()) return 'Value is required'
+        return true
+      },
+    },
+  ])
+
+  return { key, value }
+}
+
+/**
+ * Prompt for new port
+ */
 async function promptNewPort(currentPort: number): Promise<number | null> {
   const { newPort } = await inquirer.prompt<{ newPort: number }>([
     {
@@ -91,14 +174,18 @@ async function promptNewPort(currentPort: number): Promise<number | null> {
 }
 
 export const editCommand = new Command('edit')
-  .description('Edit container properties (rename or change port)')
+  .description('Edit container properties (rename, port, or database config)')
   .argument('[name]', 'Container name')
   .option('-n, --name <newName>', 'New container name')
   .option('-p, --port <port>', 'New port number', parseInt)
+  .option(
+    '--set-config <setting>',
+    'Set a database config value (e.g., max_connections=200)',
+  )
   .action(
     async (
       name: string | undefined,
-      options: { name?: string; port?: number },
+      options: { name?: string; port?: number; setConfig?: string },
     ) => {
       try {
         let containerName = name
@@ -125,8 +212,13 @@ export const editCommand = new Command('edit')
           process.exit(1)
         }
 
-        if (options.name === undefined && options.port === undefined) {
-          const action = await promptEditAction()
+        // If no options provided, prompt for what to edit
+        if (
+          options.name === undefined &&
+          options.port === undefined &&
+          options.setConfig === undefined
+        ) {
+          const action = await promptEditAction(config.engine)
           if (!action) return
 
           if (action === 'name') {
@@ -143,6 +235,13 @@ export const editCommand = new Command('edit')
             } else {
               return
             }
+          } else if (action === 'config') {
+            const configSetting = await promptConfigSetting()
+            if (configSetting) {
+              options.setConfig = `${configSetting.key}=${configSetting.value}`
+            } else {
+              return
+            }
           }
         }
 
@@ -218,6 +317,75 @@ export const editCommand = new Command('edit')
           )
         }
 
+        // Handle config change
+        if (options.setConfig) {
+          // Only PostgreSQL supports config editing for now
+          if (config.engine !== 'postgresql') {
+            console.error(
+              error(`Config editing is only supported for PostgreSQL containers`),
+            )
+            process.exit(1)
+          }
+
+          // Parse the setting (key=value format)
+          const match = options.setConfig.match(/^([a-z_]+)=(.+)$/)
+          if (!match) {
+            console.error(
+              error(
+                'Invalid config format. Use: --set-config key=value (e.g., max_connections=200)',
+              ),
+            )
+            process.exit(1)
+          }
+
+          const [, configKey, configValue] = match
+
+          // Get the PostgreSQL engine to update config
+          const engine = getEngine(config.engine)
+          const dataDir = paths.getContainerDataPath(containerName, {
+            engine: config.engine,
+          })
+
+          const spinner = createSpinner(
+            `Setting ${configKey} = ${configValue}...`,
+          )
+          spinner.start()
+
+          // Use the PostgreSQL engine's setConfigValue method
+          if ('setConfigValue' in engine) {
+            await (engine as { setConfigValue: (dataDir: string, key: string, value: string) => Promise<void> }).setConfigValue(
+              dataDir,
+              configKey,
+              configValue,
+            )
+          }
+
+          spinner.succeed(`Set ${configKey} = ${configValue}`)
+
+          // Check if container is running and warn about restart
+          const running = await processManager.isRunning(containerName, {
+            engine: config.engine,
+          })
+          if (running) {
+            console.log(
+              info(
+                '  Note: Restart the container for changes to take effect.',
+              ),
+            )
+            console.log(
+              chalk.gray(
+                `    spindb stop ${containerName} && spindb start ${containerName}`,
+              ),
+            )
+          } else {
+            console.log(
+              chalk.gray(
+                '  Config change will take effect on next container start.',
+              ),
+            )
+          }
+        }
+
         console.log()
         console.log(success('Container updated successfully'))
       } catch (err) {

package/config/engine-defaults.ts

@@ -26,6 +26,8 @@ export type EngineDefaults = {
   dataSubdir: string
   /** Client tools required for this engine */
   clientTools: string[]
+  /** Default max connections (higher than PostgreSQL default of 100 for parallel builds) */
+  maxConnections: number
 }
 
 export const engineDefaults: Record<string, EngineDefaults> = {
@@ -41,6 +43,7 @@ export const engineDefaults: Record<string, EngineDefaults> = {
     pidFileName: 'postmaster.pid',
     dataSubdir: 'data',
     clientTools: ['psql', 'pg_dump', 'pg_restore', 'pg_basebackup'],
+    maxConnections: 200, // Higher than default 100 for parallel builds (Next.js, etc.)
   },
   mysql: {
     defaultVersion: '9.0',
@@ -54,6 +57,7 @@ export const engineDefaults: Record<string, EngineDefaults> = {
     pidFileName: 'mysql.pid',
     dataSubdir: 'data',
     clientTools: ['mysql', 'mysqldump', 'mysqlpump'],
+    maxConnections: 200, // Higher than default 151 for parallel builds
   },
 }
 

package/engines/mysql/index.ts

@@ -274,6 +274,7 @@ export class MySQLEngine extends BaseEngine {
       `--pid-file=${pidFile}`,
       `--log-error=${logFile}`,
       '--bind-address=127.0.0.1',
+      `--max-connections=${engineDef.maxConnections}`, // Higher than default 151 for parallel builds
     ]
 
     return new Promise((resolve, reject) => {

package/engines/postgresql/index.ts

@@ -1,13 +1,14 @@
 import { join } from 'path'
 import { spawn, exec } from 'child_process'
 import { promisify } from 'util'
+import { readFile, writeFile } from 'fs/promises'
 import { BaseEngine } from '../base-engine'
 import { binaryManager } from '../../core/binary-manager'
 import { processManager } from '../../core/process-manager'
 import { configManager } from '../../core/config-manager'
 import { platformService } from '../../core/platform-service'
 import { paths } from '../../config/paths'
-import { defaults } from '../../config/defaults'
+import { defaults, getEngineDefaults } from '../../config/defaults'
 import {
   getBinaryUrl,
   SUPPORTED_MAJOR_VERSIONS,
@@ -151,9 +152,70 @@ export class PostgreSQLEngine extends BaseEngine {
       superuser: (options.superuser as string) || defaults.superuser,
     })
 
+    // Configure max_connections after initdb creates postgresql.conf
+    const maxConnections =
+      (options.maxConnections as number) || getEngineDefaults('postgresql').maxConnections
+    await this.setConfigValue(dataDir, 'max_connections', String(maxConnections))
+
     return dataDir
   }
 
+  /**
+   * Get the path to postgresql.conf for a container
+   */
+  getConfigPath(containerName: string): string {
+    const dataDir = paths.getContainerDataPath(containerName, {
+      engine: this.name,
+    })
+    return join(dataDir, 'postgresql.conf')
+  }
+
+  /**
+   * Set a configuration value in postgresql.conf
+   * If the setting exists (commented or not), it updates the line.
+   * If not found, appends it to the end of the file.
+   */
+  async setConfigValue(
+    dataDir: string,
+    key: string,
+    value: string,
+  ): Promise<void> {
+    const configPath = join(dataDir, 'postgresql.conf')
+    let content = await readFile(configPath, 'utf8')
+
+    // Match both commented (#key = ...) and uncommented (key = ...) lines
+    const regex = new RegExp(`^#?\\s*${key}\\s*=.*$`, 'm')
+
+    if (regex.test(content)) {
+      // Update existing line (commented or not)
+      content = content.replace(regex, `${key} = ${value}`)
+    } else {
+      // Append to end of file
+      content = content.trimEnd() + `\n${key} = ${value}\n`
+    }
+
+    await writeFile(configPath, content, 'utf8')
+  }
+
+  /**
+   * Get a configuration value from postgresql.conf
+   * Returns null if not found or commented out
+   */
+  async getConfigValue(dataDir: string, key: string): Promise<string | null> {
+    const configPath = join(dataDir, 'postgresql.conf')
+    const content = await readFile(configPath, 'utf8')
+
+    // Match only uncommented lines
+    const regex = new RegExp(`^${key}\\s*=\\s*(.+?)\\s*(?:#.*)?$`, 'm')
+    const match = content.match(regex)
+
+    if (match) {
+      // Remove quotes if present
+      return match[1].replace(/^['"]|['"]$/g, '')
+    }
+    return null
+  }
+
   /**
    * Start PostgreSQL server
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spindb",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "Spin up local database containers without Docker. A DBngin-like CLI for PostgreSQL and MySQL.",
   "type": "module",
   "bin": {
@@ -16,7 +16,8 @@
     "test:integration": "pnpm test:pg && pnpm test:mysql",
     "test:all": "pnpm test:unit && pnpm test:integration",
     "format": "prettier --write .",
-    "lint": "tsc --noEmit && eslint ."
+    "lint": "tsc --noEmit && eslint .",
+    "prepare": "husky"
   },
   "keywords": [
     "postgres",
@@ -54,6 +55,7 @@
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.10.0",
     "eslint": "^9.39.1",
+    "husky": "^9.1.7",
     "prettier": "^3.6.2",
     "typescript": "^5.3.0",
     "typescript-eslint": "^8.48.0"