@livestore/utils-dev 0.0.0-snapshot-1a48725ede0e1642a644d2972e548b7cead6c9a4 → 0.0.0-snapshot-2df821f8699de1c39c3ccfd1a7f790614b64edd9

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"]

package/src/node/WranglerDevServer/process-tree-manager.ts

@@ -0,0 +1,263 @@
+import { Command, type CommandExecutor, Effect, Schema, type Scope, Stream } from '@livestore/utils/effect'
+
+export class ProcessTreeError extends Schema.TaggedError<ProcessTreeError>()('ProcessTreeError', {
+  cause: Schema.Unknown,
+  message: Schema.String,
+  pid: Schema.Number,
+}) {}
+
+/**
+ * Finds all child processes of a given parent PID
+ */
+export const findChildProcesses = (
+  parentPid: number,
+): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const result = yield* Command.make('ps', '-o', 'pid,ppid', '-ax').pipe(
+      Command.start,
+      Effect.flatMap((command) =>
+        command.stdout.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runCollect,
+          Effect.map((chunks) => Array.from(chunks).join('')),
+        ),
+      ),
+      Effect.catchAll(() => Effect.succeed('')), // Return empty string if command fails
+    )
+
+    if (!result) return []
+
+    const lines = result.split('\n')
+    const pattern = new RegExp(`^\\s*([0-9]+)\\s+${parentPid}\\s*$`)
+
+    const childPids = lines
+      .map((line) => {
+        const match = line.trim().match(pattern)
+        return match ? Number.parseInt(match[1]!, 10) : null
+      })
+      .filter((pid): pid is number => pid !== null)
+
+    return childPids
+  })
+
+/**
+ * Recursively finds all descendants of a process
+ */
+export const findProcessTree = (
+  rootPid: number,
+): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const allPids = new Set<number>([rootPid])
+    const toProcess = [rootPid]
+
+    while (toProcess.length > 0) {
+      const currentPid = toProcess.pop()!
+      const children = yield* findChildProcesses(currentPid)
+
+      for (const childPid of children) {
+        if (!allPids.has(childPid)) {
+          allPids.add(childPid)
+          toProcess.push(childPid)
+        }
+      }
+    }
+
+    return Array.from(allPids)
+  })
+
+/**
+ * Checks if a process is running
+ */
+export const isProcessRunning = (pid: number): Effect.Effect<boolean, never, never> =>
+  Effect.sync(() => {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  })
+
+/**
+ * Kills a process tree with escalating signals
+ */
+export const killProcessTree = (
+  rootPid: number,
+  options: {
+    timeout?: number
+    signals?: NodeJS.Signals[]
+    includeRoot?: boolean
+  } = {},
+): Effect.Effect<
+  { killedPids: number[]; failedPids: number[] },
+  never,
+  CommandExecutor.CommandExecutor | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const { timeout = 5000, signals = ['SIGTERM', 'SIGKILL'], includeRoot = true } = options
+
+    // Find all processes in the tree
+    const allPids = yield* findProcessTree(rootPid)
+    const pidsToKill = includeRoot ? allPids : allPids.filter((pid) => pid !== rootPid)
+
+    if (pidsToKill.length === 0) {
+      return { killedPids: [], failedPids: [] }
+    }
+
+    const killedPids: number[] = []
+    const failedPids: number[] = []
+
+    // Try each signal with timeout
+    for (const signal of signals) {
+      // Check which processes are still running and not yet killed
+      const stillRunningChecks = yield* Effect.all(
+        pidsToKill
+          .filter((pid) => !killedPids.includes(pid))
+          .map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
+      )
+      const remainingPids = stillRunningChecks.filter(({ running }) => running).map(({ pid }) => pid)
+
+      if (remainingPids.length === 0) break
+
+      // Send signal to all remaining processes
+      for (const pid of remainingPids) {
+        yield* Effect.sync(() => {
+          try {
+            process.kill(pid, signal)
+          } catch {
+            // Process might already be dead, continue
+          }
+        })
+      }
+
+      // Wait for processes to terminate with polling
+      const waitStart = Date.now()
+      while (Date.now() - waitStart < timeout) {
+        const runningChecks = yield* Effect.all(
+          remainingPids.map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
+        )
+        const stillRunning = runningChecks.filter(({ running }) => running).map(({ pid }) => pid)
+
+        if (stillRunning.length === 0) {
+          // All processes terminated
+          killedPids.push(...remainingPids)
+          break
+        }
+
+        // Short sleep before checking again
+        yield* Effect.sleep('100 millis')
+      }
+    }
+
+    // Check final status
+    const finalChecks = yield* Effect.all(
+      pidsToKill.map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
+    )
+
+    for (const { pid, running } of finalChecks) {
+      if (!killedPids.includes(pid) && running) {
+        failedPids.push(pid)
+      }
+    }
+
+    return { killedPids, failedPids }
+  })
+
+/**
+ * Finds orphaned processes by name pattern
+ */
+export const findOrphanedProcesses = (
+  namePattern: string,
+): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    // Find processes that match the pattern and have init (PID 1) as parent
+    const result = yield* Command.make('ps', '-eo', 'pid,ppid,comm').pipe(
+      Command.start,
+      Effect.flatMap((command) =>
+        command.stdout.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runCollect,
+          Effect.map((chunks) => Array.from(chunks).join('')),
+        ),
+      ),
+      Effect.catchAll(() => Effect.succeed('')), // Return empty string if command fails
+    )
+
+    if (!result) return []
+
+    const lines = result.split('\n')
+    const patternRegex = new RegExp(namePattern)
+    const parentRegex = /^\s*(\d+)\s+1\s+/
+
+    const orphanedPids = lines
+      .filter((line) => patternRegex.test(line))
+      .map((line) => {
+        const match = line.trim().match(parentRegex)
+        return match ? Number.parseInt(match[1]!, 10) : null
+      })
+      .filter((pid): pid is number => pid !== null)
+
+    return orphanedPids
+  })
+
+/**
+ * Defensive cleanup for orphaned processes matching given patterns.
+ *
+ * This function provides fallback cleanup for edge cases where normal process
+ * termination mechanisms fail (e.g., hard crashes, SIGKILL before cleanup runs,
+ * or limitations in synchronous exit handlers). While proper process tree cleanup
+ * should prevent orphans in most cases, this serves as a safety net for scenarios
+ * where child processes become orphaned despite cleanup efforts.
+ *
+ * @param processPatterns - Array of process name patterns to search for (e.g., ['wrangler', 'workerd'])
+ * @returns Object with arrays of successfully cleaned and failed PIDs
+ */
+export const cleanupOrphanedProcesses = (
+  processPatterns: string[],
+): Effect.Effect<{ cleaned: number[]; failed: number[] }, never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const cleaned: number[] = []
+    const failed: number[] = []
+
+    // Find all orphaned processes matching the patterns
+    const allOrphanedPids: number[] = []
+    const patternCounts: Record<string, number> = {}
+
+    for (const pattern of processPatterns) {
+      const orphaned = yield* findOrphanedProcesses(pattern)
+      allOrphanedPids.push(...orphaned)
+      patternCounts[pattern] = orphaned.length
+    }
+
+    if (allOrphanedPids.length === 0) {
+      return { cleaned, failed }
+    }
+
+    const patternSummary = Object.entries(patternCounts)
+      .map(([pattern, count]) => `${count} ${pattern}`)
+      .join(', ')
+
+    yield* Effect.logInfo(
+      `Found ${allOrphanedPids.length} orphaned processes (${patternSummary}): ${allOrphanedPids.join(', ')}`,
+    )
+
+    for (const pid of allOrphanedPids) {
+      const result = yield* killProcessTree(pid, {
+        timeout: 2000,
+        signals: ['SIGTERM', 'SIGKILL'],
+        includeRoot: true,
+      }).pipe(Effect.orElse(() => Effect.succeed({ killedPids: [], failedPids: [pid] })))
+
+      if (result.failedPids.length === 0) {
+        cleaned.push(...result.killedPids)
+        yield* Effect.logInfo(
+          `Cleaned up orphaned process tree starting with ${pid} (${result.killedPids.length} processes)`,
+        )
+      } else {
+        failed.push(pid, ...result.failedPids)
+        yield* Effect.logWarning(`Failed to clean up some processes in tree ${pid}: ${result.failedPids.join(', ')}`)
+      }
+    }
+
+    return { cleaned, failed }
+  })

package/src/node/mod.ts

@@ -14,9 +14,23 @@ import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
 export { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http'
 export { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
 export * from './cmd.ts'
+export {
+  type DockerComposeArgs,
+  DockerComposeError,
+  type DockerComposeOperations,
+  DockerComposeService,
+  type LogsOptions,
+  type StartOptions,
+  startDockerComposeServicesScoped,
+} from './DockerComposeService/DockerComposeService.ts'
 export * as FileLogger from './FileLogger.ts'
-export * from './vitest-docker-compose-setup.ts'
-export * from './vitest-wrangler-setup.ts'
+export * from './WranglerDevServer/process-tree-manager.ts'
+export {
+  type StartWranglerDevServerArgs,
+  type WranglerDevServer,
+  WranglerDevServerError,
+  WranglerDevServerService,
+} from './WranglerDevServer/WranglerDevServer.ts'
 
 export const OtelLiveHttp = ({
   serviceName,

package/src/node-vitest/Vitest.ts

@@ -1,7 +1,18 @@
 import * as inspector from 'node:inspector'
 import type * as Vitest from '@effect/vitest'
 import { IS_CI } from '@livestore/utils'
-import { type Cause, Duration, Effect, identity, Layer, type OtelTracer, type Scope } from '@livestore/utils/effect'
+import {
+  type Cause,
+  Duration,
+  Effect,
+  type FastCheck as FC,
+  identity,
+  Layer,
+  type OtelTracer,
+  Predicate,
+  type Schema,
+  type Scope,
+} from '@livestore/utils/effect'
 import { OtelLiveDummy } from '@livestore/utils/node'
 import { OtelLiveHttp } from '../node/mod.ts'
 
@@ -62,3 +73,51 @@ export const withTestCtx =
       Effect.annotateLogs({ suffix }),
     ) as any
   }
+
+/**
+ * Equivalent to Vitest.prop but provides extra prop context to the test function
+ *
+ * TODO: allow for upper timelimit instead of / additional to `numRuns`
+ *
+ * TODO: Upstream to Effect
+ */
+export const asProp = <Arbs extends Vitest.Vitest.Arbitraries, A, E, R>(
+  api: Vitest.Vitest.Tester<R>,
+  name: string,
+  arbitraries: Arbs,
+  test: Vitest.Vitest.TestFunction<
+    A,
+    E,
+    R,
+    [
+      { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
+      Vitest.TestContext,
+      {
+        numRuns: number
+        /** 0-based index */
+        runIndex: number
+      },
+    ]
+  >,
+  propOptions:
+    | number
+    | (Vitest.TestOptions & {
+        fastCheck?: FC.Parameters<{
+          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
+        }>
+      }),
+) => {
+  const numRuns = Predicate.isObject(propOptions) ? (propOptions.fastCheck?.numRuns ?? 100) : 100
+  let runIndex = 0
+  return api.prop(
+    name,
+    arbitraries,
+    (properties, ctx) => {
+      if (ctx.signal.aborted) {
+        return ctx.skip('Test aborted')
+      }
+      return test(properties, ctx, { numRuns, runIndex: runIndex++ })
+    },
+    propOptions,
+  )
+}

package/dist/node/vitest-docker-compose-setup.d.ts

@@ -1,32 +0,0 @@
-import { Effect, UnknownError } from '@livestore/utils/effect';
-export declare const startDockerComposeServices: (args: StartDockerComposeServicesArgs) => Effect.Effect<void, UnknownError, never>;
-type StartDockerComposeServicesArgs = {
-    composeFilePath?: string;
-    cwd: string;
-    serviceName?: string;
-    waitForLog?: string;
-    env?: Record<string, string>;
-    healthCheck?: {
-        url: string;
-        expectedStatus?: number;
-        maxAttempts?: number;
-        delayMs?: number;
-    };
-    /** @default false */
-    forwardLogs?: boolean;
-};
-export declare const pullDockerComposeImages: ({ cwd, composeFilePath, }: Pick<StartDockerComposeServicesArgs, "composeFilePath" | "cwd">) => Effect.Effect<void, import("@effect/platform/Error").PlatformError | import("./cmd.ts").CmdError, import("@effect/platform/CommandExecutor").CommandExecutor>;
-/**
- * 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
- */
-export declare const startDockerComposeServicesPromise: ({ composeFilePath, cwd, serviceName, waitForLog, healthCheck, env, forwardLogs, }: StartDockerComposeServicesArgs) => Promise<void>;
-export {};
-//# sourceMappingURL=vitest-docker-compose-setup.d.ts.map

package/dist/node/vitest-docker-compose-setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vitest-docker-compose-setup.d.ts","sourceRoot":"","sources":["../../src/node/vitest-docker-compose-setup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAG9D,eAAO,MAAM,0BAA0B,GAAI,MAAM,8BAA8B,6CAIvB,CAAA;AAExD,KAAK,8BAA8B,GAAG;IACpC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,WAAW,CAAC,EAAE;QACZ,GAAG,EAAE,MAAM,CAAA;QACX,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB,CAAA;IACD,qBAAqB;IACrB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,2BAGrC,IAAI,CAAC,8BAA8B,EAAE,iBAAiB,GAAG,KAAK,CAAC,kKAIb,CAAA;AAErD;;;;;;;;;;GAUG;AAGH,eAAO,MAAM,iCAAiC,GAAU,mFAQrD,8BAA8B,kBA4HhC,CAAA"}