@sqldoc/db 0.0.6 → 0.0.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@sqldoc/db",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Atlas WASI integration for sqldoc -- schema types, database adapters, WASI runner",
   "exports": {
     ".": {
@@ -26,11 +26,9 @@
   },
   "dependencies": {
     "@electric-sql/pglite": "^0.4.0",
-    "@testcontainers/postgresql": "^11.13.0",
     "mysql2": "^3.20.0",
     "pg": "^8.13.0",
-    "picocolors": "1.1.1",
-    "testcontainers": "^11.13.0"
+    "picocolors": "1.1.1"
   },
   "devDependencies": {
     "@types/pg": "^8.11.0",

package/src/db/docker.ts

@@ -0,0 +1,145 @@
+/**
+ * Docker container management for ephemeral dev databases.
+ * Uses Docker CLI directly — no testcontainers dependency.
+ *
+ * Containers are labeled `sqldoc-dev` and auto-removed after 60s via --stop-timeout.
+ * On startup, stale containers (>1 min old) are cleaned up.
+ */
+import { execSync, spawnSync } from 'node:child_process'
+import * as path from 'node:path'
+
+const LABEL = 'sqldoc-dev'
+
+/** Clean up any sqldoc-dev containers older than 1 minute */
+export function cleanupStaleContainers(): void {
+  try {
+    const result = execSync(
+      `docker ps -aq --filter label=${LABEL} --filter status=running --format "{{.ID}} {{.CreatedAt}}"`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] },
+    )
+    for (const line of result.trim().split('\n').filter(Boolean)) {
+      const [id, ...dateParts] = line.split(' ')
+      const created = new Date(dateParts.join(' '))
+      if (Date.now() - created.getTime() > 60_000) {
+        spawnSync('docker', ['rm', '-f', id], { stdio: 'pipe' })
+      }
+    }
+  } catch {
+    // Docker not available or no containers — fine
+  }
+}
+
+export interface DockerContainer {
+  id: string
+  host: string
+  port: number
+  stop(): void
+}
+
+/**
+ * Start a Docker container with the given image and port mapping.
+ * Returns when the container is running and the port is mapped.
+ */
+export function startContainer(opts: {
+  image: string
+  env: Record<string, string>
+  port: number
+  readyLog: string | RegExp
+}): DockerContainer {
+  cleanupStaleContainers()
+
+  const envArgs = Object.entries(opts.env).flatMap(([k, v]) => ['-e', `${k}=${v}`])
+  const name = `sqldoc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`
+
+  const result = spawnSync(
+    'docker',
+    ['run', '-d', '--rm', '--name', name, '--label', LABEL, '-p', `0:${opts.port}`, ...envArgs, opts.image],
+    { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] },
+  )
+
+  if (result.status !== 0) {
+    throw new Error(`Failed to start Docker container: ${result.stderr}`)
+  }
+
+  const id = result.stdout.trim().slice(0, 12)
+
+  // Get mapped port
+  const portOutput = execSync(`docker port ${id} ${opts.port}`, { encoding: 'utf-8' }).trim()
+  // Format: 0.0.0.0:55432 or [::]:55432
+  const portMatch = portOutput.match(/:(\d+)$/)
+  if (!portMatch) {
+    spawnSync('docker', ['rm', '-f', id], { stdio: 'pipe' })
+    throw new Error(`Failed to get mapped port for container ${id}: ${portOutput}`)
+  }
+  const port = parseInt(portMatch[1], 10)
+
+  // Wait for ready log message
+  waitForLog(id, opts.readyLog, 30_000)
+
+  return {
+    id,
+    host: '127.0.0.1',
+    port,
+    stop() {
+      spawnSync('docker', ['rm', '-f', id], { stdio: 'pipe' })
+    },
+  }
+}
+
+/**
+ * Build a Docker image from a Dockerfile and start a container.
+ */
+export function startContainerFromDockerfile(opts: {
+  dockerfilePath: string
+  env: Record<string, string>
+  port: number
+  readyLog: string | RegExp
+}): DockerContainer {
+  const absPath = path.resolve(opts.dockerfilePath)
+  const dir = path.dirname(absPath)
+  const tag = `sqldoc-dev-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+
+  const buildResult = spawnSync('docker', ['build', '-t', tag, '-f', absPath, dir], {
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: 60_000,
+  })
+
+  if (buildResult.status !== 0 && buildResult.status !== null) {
+    throw new Error(
+      `Failed to build Docker image (exit ${buildResult.status}): ${buildResult.stderr || buildResult.stdout}`,
+    )
+  }
+  if (buildResult.error) {
+    throw new Error(`Failed to build Docker image: ${buildResult.error.message}`)
+  }
+
+  const container = startContainer({ ...opts, image: tag })
+
+  // Override stop to also remove the built image
+  const originalStop = container.stop
+  container.stop = () => {
+    originalStop()
+    spawnSync('docker', ['rmi', tag], { stdio: 'pipe' })
+  }
+
+  return container
+}
+
+/** Poll docker logs until the ready message appears or timeout */
+function waitForLog(containerId: string, pattern: string | RegExp, timeoutMs: number): void {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const logs = execSync(`docker logs ${containerId} 2>&1`, { encoding: 'utf-8' })
+      if (typeof pattern === 'string' ? logs.includes(pattern) : pattern.test(logs)) {
+        return
+      }
+    } catch {
+      // Container might not be ready yet
+    }
+    spawnSync('sleep', ['0.5'])
+  }
+  spawnSync('docker', ['rm', '-f', containerId], { stdio: 'pipe' })
+  throw new Error(`Container ${containerId} did not become ready within ${timeoutMs}ms`)
+}

package/src/db/mysql-docker.ts

@@ -1,31 +1,22 @@
-/**
- * MySQL Docker adapter using testcontainers GenericContainer.
- * Uses log-based wait strategy (same as Postgres adapter) for Bun compatibility —
- * MySqlContainer's built-in health check hangs in Bun's runtime.
- */
-import { GenericContainer, Wait } from 'testcontainers'
+import { startContainer } from './docker.ts'
 import { createMysqlAdapter } from './mysql.ts'
 import type { DatabaseAdapter } from './types.ts'
 
 /**
- * Create a Docker-based MySQL DatabaseAdapter using testcontainers.
+ * Create a Docker-based MySQL DatabaseAdapter.
  * Supports: docker://mysql:8, docker://mysql:8.0, docker://mariadb:10, etc.
  */
 export async function createMysqlDockerAdapter(devUrl: string): Promise<DatabaseAdapter> {
   const imageName = devUrl.slice('docker://'.length)
 
-  const container = await new GenericContainer(imageName)
-    .withEnvironment({
-      MYSQL_ROOT_PASSWORD: 'sqldoc',
-      MYSQL_DATABASE: 'sqldoc_dev',
-    })
-    .withExposedPorts(3306)
-    .withWaitStrategy(Wait.forLogMessage(/ready for connections.*port: 3306/, 2))
-    .start()
+  const container = startContainer({
+    image: imageName,
+    env: { MYSQL_ROOT_PASSWORD: 'sqldoc', MYSQL_DATABASE: 'sqldoc_dev' },
+    port: 3306,
+    readyLog: /ready for connections.*port: 3306/,
+  })
 
-  const host = container.getHost()
-  const port = container.getMappedPort(3306)
-  const connectionUri = `mysql://root:sqldoc@${host}:${port}/sqldoc_dev`
+  const connectionUri = `mysql://root:sqldoc@${container.host}:${container.port}/sqldoc_dev`
 
   // Retry connection — container may need a moment after port is mapped
   let mysqlAdapter: DatabaseAdapter | undefined
@@ -39,7 +30,7 @@ export async function createMysqlDockerAdapter(devUrl: string): Promise<Database
   }
 
   if (!mysqlAdapter) {
-    await container.stop()
+    container.stop()
     throw new Error(`Failed to connect to Docker MySQL at ${connectionUri}`)
   }
 
@@ -48,7 +39,7 @@ export async function createMysqlDockerAdapter(devUrl: string): Promise<Database
     exec: mysqlAdapter.exec,
     async close() {
       await mysqlAdapter.close()
-      await container.stop()
+      container.stop()
     },
   }
 }

package/src/db/postgres-docker.ts

@@ -1,68 +1,34 @@
-import * as path from 'node:path'
-import { PostgreSqlContainer } from '@testcontainers/postgresql'
-import { GenericContainer, Wait } from 'testcontainers'
+import { startContainer, startContainerFromDockerfile } from './docker.ts'
 import { createPostgresAdapter } from './postgres.ts'
 import type { DatabaseAdapter } from './types.ts'
 
 /**
- * Create a Docker-based DatabaseAdapter using testcontainers.
- * Spins up an ephemeral Postgres container, connects via pg, and
- * automatically cleans up on close() (testcontainers + Ryuk handle
- * orphan cleanup even on process crash).
+ * Create a Docker-based DatabaseAdapter for Postgres.
+ * Spins up an ephemeral container, connects via pg, cleans up on close().
  *
  * Supports:
  *   docker://postgres:16        — official or custom image
  *   dockerfile://path/to/file   — build from Dockerfile
  */
 export async function createPostgresDockerAdapter(devUrl: string): Promise<DatabaseAdapter> {
-  if (devUrl.startsWith('dockerfile://')) {
-    return createFromDockerfile(devUrl.slice('dockerfile://'.length))
-  }
-
-  // docker://image:tag
-  const imageName = devUrl.slice('docker://'.length)
-  const container = await new PostgreSqlContainer(imageName)
-    .withDatabase('sqldoc_dev')
-    .withUsername('sqldoc')
-    .withPassword('sqldoc')
-    .withExposedPorts(5432)
-    .withWaitStrategy(Wait.forLogMessage('database system is ready to accept connections', 2))
-    .start()
-
-  const pgAdapter = await createPostgresAdapter(container.getConnectionUri())
-
-  return {
-    query: pgAdapter.query,
-    exec: pgAdapter.exec,
-    async close() {
-      await pgAdapter.close()
-      await container.stop()
-    },
-  }
-}
-
-async function createFromDockerfile(dockerfilePath: string): Promise<DatabaseAdapter> {
-  const absPath = path.resolve(dockerfilePath)
-  const dir = path.dirname(absPath)
-  const file = path.basename(absPath)
-
-  const image = await GenericContainer.fromDockerfile(dir, file).build()
-
-  const container = await image
-    .withEnvironment({
-      POSTGRES_DB: 'sqldoc_dev',
-      POSTGRES_USER: 'sqldoc',
-      POSTGRES_PASSWORD: 'sqldoc',
-    })
-    .withExposedPorts(5432)
-    .withWaitStrategy(Wait.forLogMessage('database system is ready to accept connections', 2))
-    .withStartupTimeout(30_000)
-    .start()
-
-  // Wait for postgres to accept connections
-  const host = container.getHost()
-  const port = container.getMappedPort(5432)
-  const connectionUri = `postgres://sqldoc:sqldoc@${host}:${port}/sqldoc_dev`
+  const isDockerfile = devUrl.startsWith('dockerfile://')
+  const readyLog = 'database system is ready to accept connections'
+
+  const container = isDockerfile
+    ? startContainerFromDockerfile({
+        dockerfilePath: devUrl.slice('dockerfile://'.length),
+        env: { POSTGRES_DB: 'sqldoc_dev', POSTGRES_USER: 'sqldoc', POSTGRES_PASSWORD: 'sqldoc' },
+        port: 5432,
+        readyLog,
+      })
+    : startContainer({
+        image: devUrl.slice('docker://'.length),
+        env: { POSTGRES_DB: 'sqldoc_dev', POSTGRES_USER: 'sqldoc', POSTGRES_PASSWORD: 'sqldoc' },
+        port: 5432,
+        readyLog,
+      })
+
+  const connectionUri = `postgres://sqldoc:sqldoc@${container.host}:${container.port}/sqldoc_dev`
 
   // Retry connection — container may need a moment after port is mapped
   let pgAdapter: DatabaseAdapter | undefined
@@ -76,7 +42,7 @@ async function createFromDockerfile(dockerfilePath: string): Promise<DatabaseAda
   }
 
   if (!pgAdapter) {
-    await container.stop()
+    container.stop()
     throw new Error(`Failed to connect to Docker Postgres at ${connectionUri}`)
   }
 
@@ -85,7 +51,7 @@ async function createFromDockerfile(dockerfilePath: string): Promise<DatabaseAda
     exec: pgAdapter.exec,
     async close() {
       await pgAdapter.close()
-      await container.stop()
+      container.stop()
     },
   }
 }