@livestore/utils-dev 0.0.0-snapshot-8452e32b7fbfc129741b253b9c853f866b52129f.1 → 0.0.0-snapshot-f257c8dcda25d0c2b1d1e65e64e723ec930e992e

package/src/node-vitest/vitest-docker-compose-setup.ts

@@ -1,171 +0,0 @@
-import { spawn } from 'node:child_process'
-import path from 'node:path'
-import { Effect, UnknownError } from '@livestore/utils/effect'
-
-import { afterAll } from 'vitest'
-
-export const startDockerComposeServices = (args: StartDockerComposeServicesArgs) =>
-  Effect.tryPromise({
-    try: () => startDockerComposeServicesPromise(args),
-    catch: (error) => UnknownError.make({ cause: new Error(`Failed to start Docker Compose: ${error}`) }),
-  }).pipe(Effect.withSpan('startDockerComposeServices'))
-
-type StartDockerComposeServicesArgs = {
-  composeFilePath?: string
-  cwd: string
-  serviceName?: string
-  waitForLog?: string
-  env?: Record<string, string>
-  healthCheck?: {
-    url: string // URL template with ${port} placeholder
-    expectedStatus?: number // default 200
-    maxAttempts?: number // default 30
-    delayMs?: number // default 1000
-  }
-  /** @default false */
-  forwardLogs?: boolean
-}
-
-/**
- * Starts Docker Compose services for testing with automatic cleanup.
- * Automatically allocates a free port and passes it as EXPOSED_PORT environment variable.
- *
- * @param composeFilePath - Path to docker-compose.yml file (defaults to `${cwd}/docker-compose.yml`)
- * @param cwd - Working directory for Docker Compose commands
- * @param env - Environment variables to pass to the Docker Compose commands (useful for passing ports)
- * @param serviceName - Optional specific service to start (omit to start all)
- * @param waitForLog - Log pattern to wait for before considering services ready
- * @param healthCheck - Health check configuration for waiting until service is ready
- */
-// TODO refactor implementation with Effect
-// TODO add test for this
-export const startDockerComposeServicesPromise = async ({
-  composeFilePath,
-  cwd,
-  serviceName,
-  waitForLog,
-  healthCheck,
-  env,
-  forwardLogs = false,
-}: StartDockerComposeServicesArgs) => {
-  let dockerComposeProcess: ReturnType<typeof spawn> | undefined
-
-  const setup = async () => {
-    const resolvedComposeFilePath = path.resolve(composeFilePath ?? path.join(cwd, 'docker-compose.yml'))
-
-    // Build the docker compose command arguments
-    const composeArgs = ['compose', '-f', resolvedComposeFilePath, 'up']
-
-    // Add service name if specified
-    if (serviceName) {
-      composeArgs.push(serviceName)
-    }
-
-    dockerComposeProcess = spawn('docker', composeArgs, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      cwd,
-      env: { ...process.env, ...env },
-    })
-
-    dockerComposeProcess.stdout?.setEncoding('utf8')
-    dockerComposeProcess.stderr?.setEncoding('utf8')
-
-    if (forwardLogs) {
-      dockerComposeProcess.stdout?.on('data', (data: string) => {
-        console.log(data)
-      })
-
-      dockerComposeProcess.stderr?.on('data', (data: string) => {
-        console.error(data)
-      })
-    }
-
-    // Wait for the service to be ready
-    if (healthCheck) {
-      // Use health check approach
-      const maxAttempts = healthCheck.maxAttempts ?? 30
-      const delayMs = healthCheck.delayMs ?? 1000
-      const expectedStatus = healthCheck.expectedStatus ?? 200
-      const healthUrl = healthCheck.url
-
-      console.log(`Waiting for health check at ${healthUrl}...`)
-
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-          const response = await fetch(healthUrl)
-          if (response.status === expectedStatus) {
-            console.log(`Health check passed after ${attempt} attempts`)
-            break
-          }
-          console.log(`Health check attempt ${attempt}/${maxAttempts}: status ${response.status}`)
-        } catch (error) {
-          console.log(
-            `Health check attempt ${attempt}/${maxAttempts}: ${error instanceof Error ? error.message : 'failed'}`,
-          )
-        }
-
-        if (attempt === maxAttempts) {
-          throw new Error(`Health check failed after ${maxAttempts} attempts at ${healthUrl}`)
-        }
-
-        await new Promise((resolve) => setTimeout(resolve, delayMs))
-      }
-    } else if (waitForLog) {
-      // Fallback to log-based waiting
-      await new Promise<void>((resolve) => {
-        const onData = (data: string) => {
-          if (data.includes(waitForLog)) {
-            dockerComposeProcess?.stdout?.off('data', onData)
-            resolve()
-          }
-        }
-        dockerComposeProcess?.stdout?.on('data', onData)
-        dockerComposeProcess?.stderr?.on('data', onData)
-      })
-    } else {
-      // No wait condition, just give it a moment to start
-      await new Promise((resolve) => setTimeout(resolve, 2000))
-    }
-
-    console.log(`Docker Compose services ready${serviceName ? ` (${serviceName})` : ''}`)
-  }
-
-  const stopDockerComposeServices = async () => {
-    if (dockerComposeProcess) {
-      console.log('Stopping Docker Compose services...')
-
-      const resolvedComposeFilePath = path.resolve(composeFilePath ?? path.join(cwd, 'docker-compose.yml'))
-
-      // Use docker compose down to properly stop and clean up
-      const downProcess = spawn('docker', ['compose', '-f', resolvedComposeFilePath, 'down'], {
-        stdio: 'inherit',
-        cwd,
-      })
-
-      await new Promise<void>((resolve) => {
-        downProcess.on('close', () => {
-          resolve()
-        })
-      })
-
-      dockerComposeProcess.kill('SIGTERM')
-      dockerComposeProcess = undefined
-    }
-  }
-
-  process.on('exit', () => {
-    stopDockerComposeServices()
-  })
-  process.on('SIGINT', () => {
-    stopDockerComposeServices()
-  })
-  process.on('SIGTERM', () => {
-    stopDockerComposeServices()
-  })
-
-  afterAll(async () => {
-    await stopDockerComposeServices()
-  })
-
-  await setup()
-}

package/src/node-vitest/vitest-wrangler-setup.ts

@@ -1,131 +0,0 @@
-import { spawn } from 'node:child_process'
-import net from 'node:net'
-import path from 'node:path'
-import { Effect, UnknownError } from '@livestore/utils/effect'
-
-import { afterAll } from 'vitest'
-
-export type StartWranglerDevServerArgs = {
-  wranglerConfigPath?: string
-  cwd: string
-  port?: number
-}
-
-export const startWranglerDevServer = (args: StartWranglerDevServerArgs) =>
-  Effect.tryPromise({
-    try: (abortSignal) => startWranglerDevServerPromise({ ...args, abortSignal }),
-    catch: (error) => UnknownError.make({ cause: new Error(`Failed to start Wrangler: ${error}`) }),
-  }).pipe(Effect.withSpan('startWranglerDevServer'))
-
-// TODO refactor implementation with Effect
-// TODO add test for this
-// TODO allow for config to be passed in via code instead of `wrangler.toml` file
-// TODO fix zombie workerd processes causing high CPU usage - see https://github.com/livestorejs/livestore/issues/568
-/**
- * Starts a Wrangler dev server for testing with automatic cleanup.
- *
- * @param wranglerConfigPath - Path to wrangler.toml file (defaults to `${cwd}/wrangler.toml`)
- * @param cwd - Working directory for Wrangler commands
- * @returns Object with allocated port for the dev server
- */
-export const startWranglerDevServerPromise = async ({
-  wranglerConfigPath,
-  abortSignal,
-  cwd,
-  port: inputPort,
-}: {
-  wranglerConfigPath?: string
-  abortSignal?: AbortSignal
-  cwd: string
-  port?: number
-}) => {
-  let wranglerProcess: ReturnType<typeof spawn> | undefined
-
-  const getFreePort = (): Promise<number> => {
-    return new Promise((resolve, reject) => {
-      const server = net.createServer()
-      server.listen(0, () => {
-        const port = (server.address() as net.AddressInfo)?.port
-        server.close(() => {
-          if (port) {
-            resolve(port)
-          } else {
-            reject(new Error('Could not get port'))
-          }
-        })
-      })
-      server.on('error', reject)
-    })
-  }
-
-  const setup = async () => {
-    const syncPort = inputPort ?? (await getFreePort())
-
-    const resolvedWranglerConfigPath = path.resolve(wranglerConfigPath ?? path.join(cwd, 'wrangler.toml'))
-
-    wranglerProcess = spawn(
-      'bunx',
-      ['wrangler', 'dev', '--port', syncPort.toString(), '--config', resolvedWranglerConfigPath],
-      {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        cwd,
-        env: {
-          ...process.env,
-          // NODE_OPTIONS: '--inspect --inspect-port=9233',
-        },
-        signal: abortSignal,
-      },
-    )
-
-    wranglerProcess.stdout?.setEncoding('utf8')
-    wranglerProcess.stderr?.setEncoding('utf8')
-
-    wranglerProcess.stdout?.on('data', (data: string) => {
-      // console.log(`[wrangler] ${data}`)
-      console.log(data)
-    })
-
-    wranglerProcess.stderr?.on('data', (data: string) => {
-      // console.error(`[wrangler] ${data}`)
-      console.error(data)
-    })
-
-    await new Promise<void>((resolve) => {
-      const onData = (data: string) => {
-        if (data.includes('Ready on')) {
-          wranglerProcess?.stdout?.off('data', onData)
-          resolve()
-        }
-      }
-      wranglerProcess?.stdout?.on('data', onData)
-    })
-
-    console.log(`Wrangler dev server ready on port ${syncPort}`)
-
-    // Wait longer for the Cloudflare Workers runtime to fully initialize
-    // console.log('Waiting for Cloudflare Workers runtime to fully initialize...')
-    // await new Promise(resolve => setTimeout(resolve, 10000))
-
-    return { port: syncPort }
-  }
-
-  const killWranglerProcess = () => {
-    if (wranglerProcess) {
-      console.log('Killing wrangler process...')
-      wranglerProcess.kill('SIGTERM')
-      wranglerProcess = undefined
-    }
-  }
-
-  process.on('exit', killWranglerProcess)
-  process.on('SIGINT', killWranglerProcess)
-  process.on('SIGTERM', killWranglerProcess)
-
-  afterAll(() => {
-    killWranglerProcess()
-  })
-
-  const { port } = await setup()
-
-  return { port, kill: killWranglerProcess }
-}