chore: wip

Author: chrisbbreuer

src/dynamodb.ts

@@ -13,8 +13,10 @@ import { exists } from './utils'
 
 const debug = Debug('dynamodb-local')
 const JARNAME = 'DynamoDBLocal.jar'
+const DOCKER_IMAGE = 'amazon/dynamodb-local:latest'
 
 export const runningProcesses: { [port: number]: Subprocess } = {}
+export const runningContainers: { [port: number]: string } = {}
 
 export const dynamoDb = {
   async launch(options?: LaunchOptions): Promise<Subprocess | undefined> {
@@ -26,11 +28,17 @@ export const dynamoDb = {
       verbose = false,
       detached = config.local.detached,
       javaOpts = config.local.javaOpts,
+      useDocker = false,
     } = options ?? {}
 
     if (runningProcesses[port])
       return runningProcesses[port]
 
+    // Use Docker if requested
+    if (useDocker) {
+      return this.launchDocker({ port, dbPath, verbose, detached })
+    }
+
     const args = [
       '-Xrs',
       '-Djava.library.path=./DynamoDBLocal_lib',
@@ -73,10 +81,108 @@ export const dynamoDb = {
     }
   },
 
+  /**
+   * Launch DynamoDB Local using Docker
+   */
+  async launchDocker(options: {
+    port?: number
+    dbPath?: string | null
+    verbose?: boolean
+    detached?: boolean
+  }): Promise<Subprocess | undefined> {
+    const config = await getConfig()
+    const {
+      port = config.local.port,
+      dbPath = config.local.dbPath,
+      verbose = false,
+      detached = config.local.detached,
+    } = options
+
+    const containerName = `dynamodb-local-${port}`
+
+    // Check if container already exists and is running
+    const checkResult = Bun.spawnSync(['docker', 'ps', '-q', '-f', `name=${containerName}`])
+    const existingContainer = checkResult.stdout.toString().trim()
+    if (existingContainer) {
+      debug(`DynamoDB Local container already running on port ${port}`)
+      // Return a fake subprocess that represents the running container
+      if (runningProcesses[port])
+        return runningProcesses[port]
+    }
+
+    // Stop and remove any existing container with same name
+    Bun.spawnSync(['docker', 'rm', '-f', containerName], { stdout: 'ignore', stderr: 'ignore' })
+
+    const dockerArgs = [
+      'run',
+      '--rm',
+      '-d',
+      '--name', containerName,
+      '-p', `${port}:8000`,
+    ]
+
+    // Add volume mount if dbPath is specified
+    if (dbPath) {
+      const absoluteDbPath = path.resolve(dbPath)
+      await fs.promises.mkdir(absoluteDbPath, { recursive: true })
+      dockerArgs.push('-v', `${absoluteDbPath}:/home/dynamodblocal/data`)
+      dockerArgs.push(DOCKER_IMAGE, '-jar', 'DynamoDBLocal.jar', '-dbPath', '/home/dynamodblocal/data')
+    }
+    else {
+      dockerArgs.push(DOCKER_IMAGE)
+    }
+
+    debug('Launching DynamoDB Local with Docker:', dockerArgs)
+
+    try {
+      const child = Bun.spawn(['docker', ...dockerArgs], {
+        onExit: (proc, exitCode, signalCode, error) => {
+          if (exitCode !== 0 && verbose)
+            debug('Docker container exit code:', exitCode)
+          if (error)
+            debug('Docker container error:', error)
+        },
+      })
+
+      // Wait a moment for container to start
+      await new Promise(resolve => setTimeout(resolve, 1000))
+
+      // Verify container is running
+      const verifyResult = Bun.spawnSync(['docker', 'ps', '-q', '-f', `name=${containerName}`])
+      const runningContainer = verifyResult.stdout.toString().trim()
+      if (!runningContainer) {
+        throw new Error('Failed to start DynamoDB Local Docker container')
+      }
+
+      runningContainers[port] = containerName
+
+      if (!detached) {
+        process.on('exit', () => {
+          Bun.spawnSync(['docker', 'stop', containerName], { stdout: 'ignore', stderr: 'ignore' })
+        })
+      }
+
+      runningProcesses[port] = child
+      return child
+    }
+    catch (error) {
+      debug('Error launching DynamoDB Local via Docker:', error)
+      throw error
+    }
+  },
+
   stop(port: number): void {
-    const process = runningProcesses[port]
-    if (process) {
-      process.kill('SIGKILL')
+    const proc = runningProcesses[port]
+    const containerName = runningContainers[port]
+
+    if (containerName) {
+      // Stop Docker container
+      Bun.spawnSync(['docker', 'stop', containerName], { stdout: 'ignore', stderr: 'ignore' })
+      delete runningContainers[port]
+    }
+
+    if (proc) {
+      proc.kill('SIGKILL')
       delete runningProcesses[port]
     }
   },

src/types.ts

@@ -799,6 +799,11 @@ export type LaunchOptions = Partial<Pick<LocalConfig, 'port' | 'dbPath' | 'detac
    * @default false
    */
   verbose?: boolean
+  /**
+   * Use Docker to run DynamoDB Local instead of Java
+   * @default false
+   */
+  useDocker?: boolean
 }
 
 // ============================================================================