@livestore/utils-dev 0.4.0-dev.5 → 0.4.0-dev.6

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@livestore/utils-dev",
-  "version": "0.4.0-dev.5",
+  "version": "0.4.0-dev.6",
   "type": "module",
   "sideEffects": [
-    "./src/node-vitest/global.ts"
+    "./src/node-vitest/global.ts",
+    "./dist/node-vitest/global.js"
   ],
   "exports": {
     "./node": "./dist/node/mod.js",
@@ -18,7 +19,7 @@
     "@opentelemetry/sdk-metrics": "2.0.1",
     "@opentelemetry/sdk-trace-base": "2.0.1",
     "@opentelemetry/sdk-trace-node": "2.0.1",
-    "@livestore/utils": "0.4.0-dev.5"
+    "@livestore/utils": "0.4.0-dev.6"
   },
   "devDependencies": {},
   "files": [
@@ -29,10 +30,7 @@
   "license": "Apache-2.0",
   "peerDependencies": {},
   "publishConfig": {
-    "access": "public",
-    "sideEffects": [
-      "./dist/node-vitest/global.js"
-    ]
+    "access": "public"
   },
   "scripts": {
     "test": "echo 'No tests for utils-dev'"

package/src/node/DockerComposeService/DockerComposeService.test.ts

@@ -0,0 +1,91 @@
+import path from 'node:path'
+import { Duration, Effect, Layer, Stream } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+import { type DockerComposeArgs, DockerComposeService } from './DockerComposeService.ts'
+
+const testTimeout = 30_000
+const testFixturePath = path.join(import.meta.dirname, 'test-fixtures')
+
+const DockerComposeTest = (args: Partial<DockerComposeArgs> = {}) =>
+  DockerComposeService.Default({
+    cwd: testFixturePath,
+    ...args,
+  })
+
+Vitest.describe('DockerComposeService', { timeout: testTimeout }, () => {
+  Vitest.describe('Basic Operations', () => {
+    const withBasicTest = (args: Partial<DockerComposeArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => DockerComposeTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('can pull docker images', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Test that pull operation works (should succeed for hello-world image)
+        yield* dockerCompose.pull
+      }).pipe(withBasicTest()(test)),
+    )
+
+    Vitest.scopedLive('can start and stop docker compose services', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Start the service
+        yield* dockerCompose.start({ detached: true })
+
+        // Stop the service
+        yield* dockerCompose.stop
+      }).pipe(withBasicTest({ serviceName: 'hello-world' })(test)),
+    )
+
+    Vitest.scopedLive('can get logs from docker compose services', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Start the service first
+        yield* dockerCompose.start({ detached: true })
+
+        // Get logs (should contain at least the "Hello from Docker!" message)
+        const firstLogLine = yield* dockerCompose.logs().pipe(Stream.runHead)
+
+        expect(firstLogLine._tag).toBe('Some')
+
+        // Stop the service
+        yield* dockerCompose.stop
+      }).pipe(withBasicTest({ serviceName: 'hello-world' })(test)),
+    )
+  })
+
+  Vitest.describe('Health Check Operations', () => {
+    const withHealthCheckTest = (args: Partial<DockerComposeArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => DockerComposeTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('handles health check timeout gracefully', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Test starting with a health check that will timeout (invalid URL)
+        const result = yield* dockerCompose
+          .start({
+            detached: true,
+            healthCheck: {
+              url: 'http://localhost:99999/nonexistent',
+              timeout: Duration.seconds(2),
+            },
+          })
+          .pipe(Effect.either)
+
+        // Should fail due to health check timeout
+        expect(result._tag).toBe('Left')
+      }).pipe(withHealthCheckTest({ serviceName: 'hello-world' })(test)),
+    )
+  })
+})

package/src/node/DockerComposeService/DockerComposeService.ts

@@ -0,0 +1,252 @@
+import { omitUndefineds } from '@livestore/utils'
+import {
+  Command,
+  type CommandExecutor,
+  Duration,
+  Effect,
+  type PlatformError,
+  Schedule,
+  Schema,
+  type Scope,
+  Stream,
+} from '@livestore/utils/effect'
+
+export class DockerComposeError extends Schema.TaggedError<DockerComposeError>()('DockerComposeError', {
+  cause: Schema.Defect,
+  message: Schema.String,
+}) {}
+
+export interface DockerComposeArgs {
+  readonly cwd: string
+  readonly serviceName?: string
+}
+
+export interface StartOptions {
+  readonly detached?: boolean
+  readonly env?: Record<string, string>
+  readonly healthCheck?: {
+    readonly url: string
+    readonly timeout?: Duration.Duration
+    readonly interval?: Duration.Duration
+  }
+}
+
+export interface LogsOptions {
+  readonly follow?: boolean
+  readonly tail?: number
+  readonly since?: string
+}
+
+export interface DockerComposeOperations {
+  readonly pull: Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>
+  readonly start: (
+    options?: StartOptions,
+  ) => Effect.Effect<void, DockerComposeError | PlatformError.PlatformError, Scope.Scope>
+  readonly stop: Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>
+  readonly logs: (
+    options?: LogsOptions,
+  ) => Stream.Stream<string, DockerComposeError | PlatformError.PlatformError, Scope.Scope>
+}
+
+export class DockerComposeService extends Effect.Service<DockerComposeService>()('DockerComposeService', {
+  scoped: (args: DockerComposeArgs) =>
+    Effect.gen(function* () {
+      const { cwd, serviceName } = args
+
+      const commandExecutorContext = yield* Effect.context<CommandExecutor.CommandExecutor>()
+
+      const pull = Effect.gen(function* () {
+        yield* Effect.log(`Pulling Docker Compose images in ${cwd}`)
+
+        yield* Command.make('docker', 'compose', 'pull').pipe(
+          Command.workingDirectory(cwd),
+          Command.exitCode,
+          Effect.flatMap((exitCode: number) =>
+            exitCode === 0
+              ? Effect.void
+              : Effect.fail(
+                  new DockerComposeError({
+                    cause: new Error(`Docker compose pull failed with exit code ${exitCode}`),
+                    message: `Docker compose pull failed with exit code ${exitCode}`,
+                  }),
+                ),
+          ),
+          Effect.provide(commandExecutorContext),
+        )
+
+        yield* Effect.log(`Successfully pulled Docker Compose images`)
+      }).pipe(Effect.withSpan('pullDockerComposeImages'))
+
+      const start = (options: StartOptions = {}) =>
+        Effect.gen(function* () {
+          const { detached = true, healthCheck } = options
+
+          // Build start command
+          const baseArgs = ['docker', 'compose', 'up']
+          if (detached) baseArgs.push('-d')
+          if (serviceName) baseArgs.push(serviceName)
+
+          const command = yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.env(options.env ?? {}),
+            Command.start,
+            Effect.catchAll((cause) =>
+              Effect.fail(
+                new DockerComposeError({
+                  cause,
+                  message: `Failed to start Docker Compose services in ${cwd}`,
+                }),
+              ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          // Wait for command completion
+          yield* command.exitCode.pipe(
+            Effect.flatMap((exitCode: number) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose exited with code ${exitCode}`),
+                      message: `Docker Compose failed to start with exit code ${exitCode}`,
+                    }),
+                  ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          // Perform health check if requested
+          if (healthCheck) {
+            yield* performHealthCheck(healthCheck).pipe(Effect.provide(commandExecutorContext))
+          }
+
+          yield* Effect.log(`Docker Compose services started successfully in ${cwd}`)
+        }).pipe(Effect.withSpan('startDockerCompose'))
+
+      const stop = Effect.gen(function* () {
+        yield* Effect.log(`Stopping Docker Compose services in ${cwd}`)
+
+        const stopCommand = serviceName
+          ? Command.make('docker', 'compose', 'stop', serviceName)
+          : Command.make('docker', 'compose', 'stop')
+
+        yield* stopCommand.pipe(
+          Command.workingDirectory(cwd),
+          Command.exitCode,
+          Effect.flatMap((exitCode: number) =>
+            exitCode === 0
+              ? Effect.void
+              : Effect.fail(
+                  new DockerComposeError({
+                    cause: new Error(`Docker compose stop exited with code ${exitCode}`),
+                    message: `Failed to stop Docker Compose services`,
+                  }),
+                ),
+          ),
+          Effect.provide(commandExecutorContext),
+        )
+
+        yield* Effect.log(`Docker Compose services stopped successfully`)
+      }).pipe(Effect.withSpan('stopDockerCompose'))
+
+      const logs = (options: LogsOptions = {}) =>
+        Effect.gen(function* () {
+          const { follow = false, tail, since } = options
+
+          const baseArgs = ['docker', 'compose', 'logs']
+          if (follow) baseArgs.push('-f')
+          if (tail) baseArgs.push('--tail', tail.toString())
+          if (since) baseArgs.push('--since', since)
+          if (serviceName) baseArgs.push(serviceName)
+
+          const command = yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.start,
+            Effect.catchAll((cause) =>
+              Effect.fail(
+                new DockerComposeError({
+                  cause,
+                  message: `Failed to read Docker Compose logs in ${cwd}`,
+                }),
+              ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          return command.stdout.pipe(
+            Stream.decodeText('utf8'),
+            Stream.splitLines,
+            Stream.mapError(
+              (cause) =>
+                new DockerComposeError({
+                  cause,
+                  message: `Error reading Docker Compose logs in ${cwd}`,
+                }),
+            ),
+          )
+        }).pipe(Stream.unwrapScoped)
+
+      return { pull, start, stop, logs }
+    }),
+}) {}
+
+const performHealthCheck = ({
+  url,
+  timeout = Duration.minutes(2),
+  interval = Duration.seconds(2),
+}: {
+  url: string
+  timeout?: Duration.Duration
+  interval?: Duration.Duration
+}): Effect.Effect<void, DockerComposeError, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    yield* Effect.log(`Performing health check on ${url}`)
+
+    const checkHealth = Command.make('curl', '-f', '-s', url).pipe(
+      Command.exitCode,
+      Effect.map((code: number) => code === 0),
+      Effect.catchAll(() => Effect.succeed(false)),
+    )
+
+    const healthCheck = checkHealth.pipe(
+      Effect.repeat({
+        while: (healthy: boolean) => !healthy,
+        schedule: Schedule.fixed(interval),
+      }),
+      Effect.timeout(timeout),
+      Effect.catchAll(() =>
+        Effect.fail(
+          new DockerComposeError({
+            cause: new Error('Health check timeout'),
+            message: `Health check failed for ${url} after ${Duration.toMillis(timeout)}ms`,
+          }),
+        ),
+      ),
+    )
+
+    yield* healthCheck
+    yield* Effect.log(`Health check passed for ${url}`)
+  })
+
+// Convenience function for scoped Docker Compose operations with automatic cleanup
+export const startDockerComposeServicesScoped = (
+  args: DockerComposeArgs & {
+    healthCheck?: StartOptions['healthCheck']
+  },
+): Effect.Effect<
+  void,
+  DockerComposeError | PlatformError.PlatformError,
+  DockerComposeService | CommandExecutor.CommandExecutor | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const dockerCompose = yield* DockerComposeService
+
+    // Start the services
+    yield* dockerCompose.start({
+      ...omitUndefineds({ healthCheck: args.healthCheck ? args.healthCheck : undefined }),
+    })
+
+    // Add cleanup finalizer to the current scope
+    yield* Effect.addFinalizer(() => dockerCompose.stop.pipe(Effect.orDie))
+  })

package/src/node/DockerComposeService/test-fixtures/docker-compose.yml

@@ -0,0 +1,4 @@
+services:
+  hello-world:
+    image: hello-world
+    profiles: [manual] # Don't auto-start this service

package/src/node/WranglerDevServer/WranglerDevServer.test.ts

@@ -0,0 +1,266 @@
+import { Effect, Exit, FetchHttpClient, Fiber, Layer, Scope } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+import {
+  type StartWranglerDevServerArgs,
+  WranglerDevServerError,
+  WranglerDevServerService,
+} from './WranglerDevServer.ts'
+
+const testTimeout = 60_000
+
+const withTestCtx = Vitest.makeWithTestCtx({
+  timeout: testTimeout,
+  makeLayer: () => PlatformNode.NodeContext.layer,
+})
+
+const WranglerDevServerTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+  WranglerDevServerService.Default({
+    cwd: `${import.meta.dirname}/fixtures`,
+    ...args,
+  }).pipe(Layer.provide(FetchHttpClient.layer))
+
+Vitest.describe('WranglerDevServer', { timeout: testTimeout }, () => {
+  Vitest.describe('Basic Operations', () => {
+    const withBasicTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should start wrangler dev server and return port', (test) =>
+      Effect.gen(function* () {
+        const server = yield* WranglerDevServerService
+
+        expect(server.port).toBeGreaterThan(0)
+        expect(server.url).toMatch(/http:\/\/localhost:\d+/)
+        expect(typeof server.processId).toBe('number')
+        expect(server.processId).toBeGreaterThan(0)
+      }).pipe(withBasicTest()(test)),
+    )
+
+    Vitest.scopedLive('should use specified port when provided', (test) =>
+      Effect.gen(function* () {
+        const server = yield* WranglerDevServerService
+
+        expect(server.port).toBe(54443)
+        expect(server.url).toBe(`http://localhost:54443`)
+      }).pipe(withBasicTest({ port: 54443 })(test)),
+    )
+  })
+
+  Vitest.describe('Resource Management', () => {
+    Vitest.scopedLive('should cleanup processes on scope close', (test) =>
+      Effect.gen(function* () {
+        let processId: number | undefined
+
+        // Create a separate scope for the server
+        const serverScope = yield* Scope.make()
+
+        const server = yield* Effect.provide(
+          WranglerDevServerService,
+          WranglerDevServerTest().pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        ).pipe(Scope.extend(serverScope))
+
+        processId = server.processId
+        expect(processId).toBeGreaterThan(0)
+        expect(server.port).toBeGreaterThan(0)
+        expect(server.url).toMatch(/http:\/\/localhost:\d+/)
+
+        // Close scope to trigger cleanup
+        yield* Scope.close(serverScope, Exit.succeed(void 0))
+
+        // Wait for cleanup to complete
+        yield* Effect.sleep('2 seconds')
+
+        // Verify process is terminated
+        const isRunning2 = yield* Effect.promise(() => {
+          try {
+            process.kill(processId!, 0)
+            return Promise.resolve(true)
+          } catch {
+            return Promise.resolve(false)
+          }
+        })
+        expect(isRunning2).toBe(false)
+      }).pipe(withTestCtx(test)),
+    )
+
+    Vitest.scopedLive('should handle interruption with fast cleanup', (test) =>
+      Effect.gen(function* () {
+        let processId: number | undefined
+
+        const fiber = yield* Effect.fork(
+          Effect.provide(
+            Effect.gen(function* () {
+              const server = yield* WranglerDevServerService
+              processId = server.processId
+              yield* Effect.sleep('30 seconds') // Keep running
+              return server
+            }),
+            WranglerDevServerTest().pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+          ),
+        )
+
+        // Wait for server to start
+        yield* Effect.sleep('3 seconds')
+
+        expect(processId).toBeGreaterThan(0)
+
+        // Interrupt and measure cleanup time
+        const start = Date.now()
+        yield* Fiber.interrupt(fiber)
+        const elapsed = Date.now() - start
+
+        // Should use fast cleanup (500ms timeout) + some overhead
+        expect(elapsed).toBeLessThan(1500) // Allow some overhead
+
+        // Wait for cleanup to complete
+        yield* Effect.sleep('1 second')
+
+        // Verify process is terminated
+        const isRunningAfter = yield* Effect.promise(() => {
+          try {
+            process.kill(processId!, 0)
+            return Promise.resolve(true)
+          } catch {
+            return Promise.resolve(false)
+          }
+        })
+        expect(isRunningAfter).toBe(false)
+      }).pipe(withTestCtx(test)),
+    )
+  })
+
+  Vitest.describe('Error Handling', () => {
+    const withErrorTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should handle missing wrangler.toml but should timeout', (test) =>
+      Effect.gen(function* () {
+        const error = yield* WranglerDevServerService.pipe(
+          Effect.provide(
+            WranglerDevServerTest({
+              cwd: '/tmp',
+              wranglerConfigPath: '/dev/null',
+              connectTimeout: '500 millis',
+            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+          ),
+          Effect.flip,
+        )
+
+        expect(error).toBeInstanceOf(WranglerDevServerError)
+      }).pipe(Vitest.withTestCtx(test)),
+    )
+
+    Vitest.scopedLive('should handle invalid working directory', (test) =>
+      Effect.gen(function* () {
+        const result = yield* WranglerDevServerService.pipe(
+          Effect.provide(
+            WranglerDevServerTest({
+              cwd: '/completely/nonexistent/directory',
+            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+          ),
+          Effect.either,
+        )
+
+        expect(result._tag).toBe('Left')
+        if (result._tag === 'Left') {
+          expect(result.left).toBeInstanceOf(WranglerDevServerError)
+        }
+      }).pipe(Vitest.withTestCtx(test)),
+    )
+
+    Vitest.scopedLive('should timeout if server fails to start', (test) =>
+      Effect.gen(function* () {
+        // Create a command that will never output "Ready on"
+        const result = yield* WranglerDevServerService.pipe(
+          // Override the timeout for this test to be shorter
+          Effect.timeout('5 seconds'),
+          Effect.either,
+        )
+
+        // This might succeed or fail depending on actual wrangler behavior
+        // The main point is testing timeout functionality
+        expect(['Left', 'Right']).toContain(result._tag)
+      }).pipe(withErrorTest()(test)),
+    )
+  })
+
+  Vitest.describe('Process Tree Cleanup', () => {
+    const withCleanupTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should clean up child workerd processes', (test) =>
+      Effect.gen(function* () {
+        let processId: number | undefined
+
+        const server = yield* WranglerDevServerService
+        processId = server.processId
+
+        // Wait for wrangler to spawn workerd children
+        yield* Effect.sleep('3 seconds')
+
+        // Find any child processes (workerd)
+        const children = yield* Effect.promise(async () => {
+          const { exec } = require('node:child_process')
+          const { promisify } = require('node:util')
+          const execAsync = promisify(exec)
+
+          try {
+            if (!processId) throw new Error('processId is undefined')
+            const { stdout } = await execAsync(`ps -o pid,ppid -ax | grep -E "^\\s*[0-9]+\\s+${processId}\\s*$"`)
+            return stdout
+              .trim()
+              .split('\n')
+              .map((line: string) => {
+                const match = line.trim().match(/^\s*(\d+)\s+\d+\s*$/)
+                return match?.[1] ? Number.parseInt(match[1], 10) : null
+              })
+              .filter((pid: number | null): pid is number => pid !== null)
+          } catch {
+            return []
+          }
+        })
+
+        console.log(`Found ${children.length} child processes:`, children)
+
+        // The scope will close here and should clean up all processes
+      }).pipe(withCleanupTest()(test)),
+    )
+  })
+
+  Vitest.describe('Service Pattern', () => {
+    const withServiceTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should work with service pattern', (test) =>
+      Effect.gen(function* () {
+        const server = yield* WranglerDevServerService
+
+        expect(server.port).toBeGreaterThan(0)
+        expect(server.url).toMatch(/http:\/\/localhost:\d+/)
+        expect(server.processId).toBeGreaterThan(0)
+      }).pipe(withServiceTest()(test)),
+    )
+
+    Vitest.scopedLive('should work with custom port via service', (test) =>
+      Effect.gen(function* () {
+        const server = yield* WranglerDevServerService
+
+        expect(server.port).toBe(54444)
+        expect(server.url).toBe('http://localhost:54444')
+      }).pipe(withServiceTest({ port: 54444 })(test)),
+    )
+  })
+})