@livestore/utils-dev 0.0.0-snapshot-d677008bdbdee9280bb55474e2e095d3d09a6d60 → 0.0.0-snapshot-61ffc7dbe7378bd127038444529800e35e2ebb4b

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

@@ -1,270 +0,0 @@
-import { Effect, Exit, FetchHttpClient, Fiber, Layer, Scope } from '@livestore/utils/effect'
-import { getFreePort, 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.andThen(getFreePort, (port) =>
-        Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
-
-          expect(server.port).toBe(port)
-          expect(server.url).toBe(`http://localhost:${port}`)
-        }).pipe(withBasicTest({ preferredPort: port })(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.andThen(getFreePort, (port) =>
-        Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
-
-          expect(server.port).toBe(port)
-          expect(server.url).toBe(`http://localhost:${port}`)
-        }).pipe(withServiceTest({ preferredPort: port })(test)),
-      ),
-    )
-  })
-})

package/src/node/WranglerDevServer/WranglerDevServer.ts

@@ -1,302 +0,0 @@
-import { error } from 'node:console'
-import * as path from 'node:path'
-import { IS_CI, shouldNeverHappen } from '@livestore/utils'
-import {
-  Command,
-  Duration,
-  Effect,
-  Exit,
-  HttpClient,
-  Option,
-  type PlatformError,
-  Schedule,
-  Schema,
-  Stream,
-} from '@livestore/utils/effect'
-import { getFreePort } from '@livestore/utils/node'
-import { cleanupOrphanedProcesses, killProcessTree } from './process-tree-manager.ts'
-
-/**
- * Error type for WranglerDevServer operations
- */
-export class WranglerDevServerError extends Schema.TaggedError<WranglerDevServerError>()('WranglerDevServerError', {
-  cause: Schema.Unknown,
-  message: Schema.String,
-  port: Schema.Number,
-}) {}
-
-/**
- * WranglerDevServer instance interface
- */
-export interface WranglerDevServer {
-  readonly port: number
-  readonly url: string
-  readonly processId: number
-}
-
-/**
- * Configuration for starting WranglerDevServer
- */
-export interface StartWranglerDevServerArgs {
-  wranglerConfigPath?: string
-  cwd: string
-  /** The port to try first. The dev server may bind a different port if unavailable. */
-  preferredPort?: number
-  /** @default false */
-  showLogs?: boolean
-  inspectorPort?: number
-  connectTimeout?: Duration.DurationInput
-}
-
-/**
- * WranglerDevServer as an Effect.Service.
- *
- * This service provides the WranglerDevServer properties and can be accessed
- * directly to get port, url, and processId.
- *
- * TODO: Allow for config to be passed in via code instead of `wrangler.toml` file
- * (would need to be placed in temporary file as wrangler only accepts files as config)
- */
-export class WranglerDevServerService extends Effect.Service<WranglerDevServerService>()('WranglerDevServerService', {
-  scoped: (args: StartWranglerDevServerArgs) =>
-    Effect.gen(function* () {
-      const showLogs = args.showLogs ?? false
-
-      // Clean up any orphaned processes before starting (defensive cleanup)
-      yield* cleanupOrphanedProcesses(['wrangler', 'workerd']).pipe(
-        Effect.tap((result) =>
-          showLogs && (result.cleaned.length > 0 || result.failed.length > 0)
-            ? Effect.logInfo(`Cleanup result: ${result.cleaned.length} cleaned, ${result.failed.length} failed`)
-            : Effect.void,
-        ),
-        Effect.ignore, // Don't fail startup if cleanup fails
-      )
-
-      // Allocate preferred port (Wrangler may bind a different one if unavailable)
-      const preferredPort =
-        args.preferredPort ??
-        (yield* getFreePort.pipe(
-          Effect.mapError(
-            (cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 }),
-          ),
-        ))
-
-      yield* Effect.annotateCurrentSpan({ preferredPort })
-
-      // Resolve config path
-      const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
-
-      const inspectorPort = args.inspectorPort ?? (yield* getFreePort)
-
-      // Start wrangler process using Effect Command
-      const process = yield* Command.make(
-        'bunx',
-        'wrangler',
-        'dev',
-        '--port',
-        preferredPort.toString(),
-        '--inspector-port',
-        inspectorPort.toString(),
-        '--config',
-        configPath,
-      ).pipe(
-        Command.workingDirectory(args.cwd),
-        Command.stdout('pipe'),
-        Command.stderr('pipe'),
-        Command.start,
-        Effect.catchAllCause(
-          (error) =>
-            new WranglerDevServerError({
-              cause: error,
-              message: `Failed to start wrangler process in directory: ${args.cwd}`,
-              port: preferredPort,
-            }),
-        ),
-        Effect.withSpan('WranglerDevServerService:startProcess'),
-      )
-
-      if (showLogs) {
-        yield* process.stderr.pipe(
-          Stream.decodeText('utf8'),
-          Stream.tapLogWithLabel('wrangler:stderr'),
-          Stream.runDrain,
-          Effect.forkScoped,
-        )
-      }
-
-      const processId = process.pid
-
-      // We need to keep the `stdout` stream open, as we drain it in the waitForReady function
-      // Otherwise we'll get a EPIPE error
-      const stdout = yield* Stream.broadcastDynamic(process.stdout, 100)
-
-      // Register cleanup finalizer with intelligent timeout handling
-      yield* Effect.addFinalizer((exit) =>
-        Effect.gen(function* () {
-          const isInterrupted = Exit.isInterrupted(exit)
-          if (showLogs) {
-            yield* Effect.logDebug(`Cleaning up wrangler process ${processId}, interrupted: ${isInterrupted}`)
-          }
-          // yield* Effect.logDebug(`Cleaning up wrangler process ${processId}, interrupted: ${isInterrupted}`)
-
-          // Check if process is still running
-          const isRunning = yield* process.isRunning
-
-          if (isRunning) {
-            // Use our enhanced process tree cleanup
-            yield* killProcessTree(processId, {
-              timeout: isInterrupted ? 500 : 3000, // Fast cleanup on interruption
-              signals: ['SIGTERM', 'SIGKILL'],
-              includeRoot: true,
-            }).pipe(
-              Effect.tap((result) =>
-                showLogs
-                  ? Effect.logDebug(
-                      `Cleaned up ${result.killedPids.length} processes, ${result.failedPids.length} failed`,
-                    )
-                  : Effect.void,
-              ),
-              Effect.mapError(
-                (error) =>
-                  new WranglerDevServerError({
-                    cause: error,
-                    message: `Failed to kill process tree for PID ${processId}`,
-                    port: 0,
-                  }),
-              ),
-              Effect.ignore, // Don't fail the finalizer if cleanup has issues
-            )
-
-            // Also kill the command process handle
-            yield* process.kill()
-          } else if (showLogs) {
-            yield* Effect.logDebug(`Process ${processId} already terminated`)
-          }
-        }).pipe(
-          Effect.withSpan('WranglerDevServerService:cleanupProcess'),
-          Effect.timeout('5 seconds'), // Don't let cleanup hang forever
-          Effect.ignoreLogged,
-        ),
-      )
-
-      // Wait for server to be ready and parse the actual bound host:port from stdout
-      const readyInfo = yield* waitForReady({ stdout, showLogs })
-
-      const actualPort = readyInfo.port
-      const actualHost = readyInfo.host
-      const url = `http://${actualHost}:${actualPort}`
-
-      // Use longer timeout in CI environments to account for slower startup times
-      const defaultTimeout = Duration.seconds(IS_CI ? 30 : 5)
-
-      yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: args.connectTimeout ?? defaultTimeout })
-
-      if (showLogs) {
-        yield* Effect.logDebug(
-          `Wrangler dev server ready and accepting connections on port ${actualPort} (preferred: ${preferredPort})`,
-        )
-      }
-
-      return {
-        port: actualPort,
-        url,
-        processId,
-      } satisfies WranglerDevServer
-    }).pipe(
-      Effect.withSpan('WranglerDevServerService', {
-        attributes: { preferredPort: args.preferredPort ?? 'auto', cwd: args.cwd },
-      }),
-    ),
-}) {}
-
-/**
- * Waits for Wrangler server to be ready by monitoring stdout for "Ready on" message
- */
-const waitForReady = ({
-  stdout,
-  showLogs,
-}: {
-  stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError, never>
-  showLogs: boolean
-}): Effect.Effect<{ host: string; port: number }, WranglerDevServerError, never> =>
-  stdout.pipe(
-    Stream.decodeText('utf8'),
-    Stream.splitLines,
-    Stream.tap((line) => (showLogs ? Effect.logDebug(`[wrangler] ${line}`) : Effect.void)),
-    // Find the first readiness line and try to parse the port from it
-    Stream.filterMap<string, { host: string; port: number }>((line) => {
-      if (line.includes('Ready on')) {
-        // Expect: "Ready on http://<host>:<port>"
-        const m = line.match(/https?:\/\/([^:\s]+):(\d+)/i)
-        if (!m) return shouldNeverHappen('Could not parse host:port from Wrangler "Ready on" line', line)
-        const host = m[1]! as string
-        const port = Number.parseInt(m[2]!, 10)
-        if (!Number.isFinite(port)) return shouldNeverHappen('Parsed non-finite port from Wrangler output', line)
-        return Option.some({ host, port } as const)
-      } else {
-        return Option.none()
-      }
-    }),
-    Stream.take(1),
-    Stream.runHead,
-    Effect.flatten,
-    Effect.orElse(
-      () =>
-        new WranglerDevServerError({
-          cause: 'WranglerReadyLineMissing',
-          message: 'Wrangler server did not emit a "Ready on" line',
-          port: 0,
-        }),
-    ),
-    Effect.timeoutFail({
-      duration: '30 seconds',
-      onTimeout: () =>
-        new WranglerDevServerError({
-          cause: error,
-          message: 'Wrangler server failed to start within timeout',
-          port: 0,
-        }),
-    }),
-  )
-
-/**
- * Verifies the server is actually accepting HTTP connections by making a test request
- */
-const verifyHttpConnectivity = ({
-  url,
-  showLogs,
-  connectTimeout,
-}: {
-  url: string
-  showLogs: boolean
-  connectTimeout: Duration.DurationInput
-}): Effect.Effect<void, WranglerDevServerError, HttpClient.HttpClient> =>
-  Effect.gen(function* () {
-    const client = yield* HttpClient.HttpClient
-
-    if (showLogs) {
-      yield* Effect.logDebug(`Verifying HTTP connectivity to ${url}`)
-    }
-
-    // Try to connect with retries using exponential backoff
-    yield* client.get(url).pipe(
-      Effect.retryOrElse(
-        Schedule.exponential('50 millis', 2).pipe(
-          Schedule.jittered,
-          Schedule.intersect(Schedule.elapsed.pipe(Schedule.whileOutput(Duration.lessThanOrEqualTo(connectTimeout)))),
-          Schedule.compose(Schedule.count),
-        ),
-        (error, attemptCount) =>
-          Effect.fail(
-            new WranglerDevServerError({
-              cause: error,
-              message: `Failed to establish HTTP connection to Wrangler server at ${url} after ${attemptCount} attempts (timeout: ${Duration.toMillis(connectTimeout)}ms)`,
-              port: 0,
-            }),
-          ),
-      ),
-      Effect.tap(() => (showLogs ? Effect.logDebug(`HTTP connectivity verified for ${url}`) : Effect.void)),
-      Effect.asVoid,
-      Effect.withSpan('verifyHttpConnectivity'),
-    )
-  })