@livestore/utils-dev 0.0.0-snapshot-1c345a0e6695466bdc7c4483444e7b3513620261 → 0.0.0-snapshot-92c31f56117b4fd377b66f55163ed565795c5e4c

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

@@ -0,0 +1,268 @@
+import { Effect, Exit, 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,
+  })
+
+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', (test) =>
+      Effect.gen(function* () {
+        // Since Wrangler can work without a config file, let's test with a truly invalid scenario
+        const result = yield* WranglerDevServerService.pipe(Effect.either)
+
+        // Note: Wrangler might still succeed even with /dev/null, so this test
+        // verifies our implementation handles the case properly, whether it succeeds or fails
+        expect(['Left', 'Right']).toContain(result._tag)
+
+        if (result._tag === 'Left') {
+          // If it fails, it should be a wrapped error
+          expect(result.left).toBeInstanceOf(WranglerDevServerError)
+        } else {
+          // If it succeeds, the server should be properly configured
+          expect(result.right.port).toBeGreaterThan(0)
+        }
+      }).pipe(withErrorTest({ cwd: '/tmp', wranglerConfigPath: '/dev/null' })(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)),
+    )
+  })
+})

package/src/node/WranglerDevServer/WranglerDevServer.ts

@@ -0,0 +1,206 @@
+import * as path from 'node:path'
+
+import { Command, Effect, Exit, type PlatformError, 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
+  port?: number
+  /** @default false */
+  showLogs?: boolean
+}
+
+/**
+ * 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 port
+      const port =
+        args.port ??
+        (yield* getFreePort.pipe(
+          Effect.mapError(
+            (cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 }),
+          ),
+        ))
+
+      yield* Effect.annotateCurrentSpan({ port })
+
+      // Resolve config path
+      const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
+
+      // Start wrangler process using Effect Command
+      const process = yield* Command.make(
+        'bunx',
+        'wrangler',
+        'dev',
+        '--port',
+        port.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,
+            }),
+        ),
+        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.timeout('5 seconds'), // Don't let cleanup hang forever
+          Effect.ignoreLogged,
+        ),
+      )
+
+      // Wait for server to be ready
+      yield* waitForReady({ stdout, showLogs })
+
+      if (showLogs) {
+        yield* Effect.logDebug(`Wrangler dev server ready on port ${port}`)
+      }
+
+      return {
+        port,
+        url: `http://localhost:${port}`,
+        processId,
+      } satisfies WranglerDevServer
+    }).pipe(
+      Effect.withSpan('WranglerDevServerService', {
+        attributes: { port: args.port ?? '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<void, WranglerDevServerError, never> =>
+  stdout.pipe(
+    Stream.decodeText('utf8'),
+    Stream.splitLines,
+    Stream.tap((line) => (showLogs ? Effect.logDebug(`[wrangler] ${line}`) : Effect.void)),
+    Stream.takeUntil((line) => line.includes('Ready on')),
+    Stream.runDrain,
+    Effect.timeout('30 seconds'),
+    Effect.mapError(
+      (error) =>
+        new WranglerDevServerError({
+          cause: error,
+          message: 'Wrangler server failed to start within timeout',
+          port: 0,
+        }),
+    ),
+  )

package/src/node/WranglerDevServer/fixtures/cf-worker.ts

@@ -0,0 +1,11 @@
+export default {
+  async fetch(_request: Request): Promise<Response> {
+    return new Response('Hello from Wrangler Dev Server test worker!')
+  },
+}
+
+export class TestDO {
+  async fetch(_request: Request): Promise<Response> {
+    return new Response('Hello from Test Durable Object!')
+  }
+}

package/src/node/WranglerDevServer/fixtures/wrangler.toml

@@ -0,0 +1,11 @@
+name = "wrangler-dev-server-test"
+main = "./cf-worker.ts"
+compatibility_date = "2024-05-12"
+
+[[durable_objects.bindings]]
+name = "TEST_DO"
+class_name = "TestDO"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["TestDO"]