@livestore/utils 0.4.0 → 0.5.0-dev.0

package/src/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -1,148 +0,0 @@
-import process from 'node:process'
-
-import { WorkerError } from '@effect/platform/WorkerError'
-import type { CloseLatch } from '@effect/platform/WorkerRunner'
-import * as Runner from '@effect/platform/WorkerRunner'
-import * as Cause from 'effect/Cause'
-import * as Context from 'effect/Context'
-import * as Deferred from 'effect/Deferred'
-import * as Effect from 'effect/Effect'
-import * as Exit from 'effect/Exit'
-import * as FiberSet from 'effect/FiberSet'
-import * as Layer from 'effect/Layer'
-import * as Runtime from 'effect/Runtime'
-import * as Scope from 'effect/Scope'
-
-// Parent death monitoring setup
-let parentDeathDetectionEnabled = false
-let parentDeathTimer: NodeJS.Timeout | null = null
-
-type SetupParentDeathDetectionMessage = ['setup-parent-death-detection', { parentPid: number }]
-type RunnerMessage<I> = Runner.BackingRunner.Message<I> | SetupParentDeathDetectionMessage
-
-const isSetupParentDeathDetectionMessage = (
-  message: unknown,
-): message is SetupParentDeathDetectionMessage =>
-  Array.isArray(message) &&
-  message[0] === 'setup-parent-death-detection' &&
-  typeof message[1] === 'object' &&
-  message[1] !== null &&
-  'parentPid' in message[1] &&
-  typeof (message[1] as { parentPid: unknown }).parentPid === 'number'
-
-const stopParentDeathMonitoring = () => {
-  parentDeathDetectionEnabled = false
-  if (parentDeathTimer !== null) {
-    clearTimeout(parentDeathTimer)
-    parentDeathTimer = null
-  }
-}
-
-const setupParentDeathMonitoring = (parentPid: number) => {
-  if (parentDeathDetectionEnabled === true) return
-  parentDeathDetectionEnabled = true
-
-  let consecutiveFailures = 0
-  const maxFailures = 3 // Require 3 consecutive failures before self-terminating
-
-  // Check if parent is still alive every 2 seconds (more conservative)
-  const checkParentAlive = () => {
-    if (parentDeathDetectionEnabled === false) return
-    try {
-      // Send signal 0 to check if process exists (doesn't actually send signal)
-      process.kill(parentPid, 0)
-      // If we reach here, parent is still alive, reset failure counter and check again later
-      consecutiveFailures = 0
-      parentDeathTimer = setTimeout(checkParentAlive, 2000)
-    } catch {
-      consecutiveFailures++
-      console.warn(`[Worker ${process.pid}] Parent check failed (${consecutiveFailures}/${maxFailures})`)
-
-      if (consecutiveFailures >= maxFailures) {
-        // Parent process has been gone for multiple checks, self-terminate
-        console.error(`[Worker ${process.pid}] Parent process ${parentPid} confirmed dead, self-terminating`)
-        process.exit(0)
-      } else {
-        // Try again sooner on failure
-        parentDeathTimer = setTimeout(checkParentAlive, 1000)
-      }
-    }
-  }
-
-  // Start monitoring after a longer initial delay to let things settle
-  parentDeathTimer = setTimeout(checkParentAlive, 5000)
-}
-
-const platformRunnerImpl = Runner.PlatformRunner.of({
-  [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
-  start<I, O>(closeLatch: typeof CloseLatch.Service) {
-    return Effect.gen(function* () {
-      if (process.send == null) {
-        return yield* new WorkerError({ reason: 'spawn', cause: new Error('not in a child process') })
-      }
-      const port = {
-        postMessage: (message: any) => process.send!(message),
-        on: (event: string, handler: (message: any) => void) => process.on(event, handler),
-        close: () => process.disconnect?.(),
-      }
-      const send = (_portId: number, message: O, _transfers?: ReadonlyArray<unknown>) =>
-        Effect.sync(() => port.postMessage([1, message] /*, transfers as any*/))
-
-      const run = Effect.fnUntraced(function* <A, E, R>(
-        // biome-ignore lint/suspicious/noConfusingVoidType: need to support void
-        handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void,
-      ) {
-        const runtime = (yield* Effect.interruptible(Effect.runtime<R | Scope.Scope>())).pipe(
-          Runtime.updateContext(Context.omit(Scope.Scope)),
-        ) as Runtime.Runtime<R>
-        const fiberSet = yield* FiberSet.make<any, WorkerError | E>()
-        const runFork = Runtime.runFork(runtime)
-        const onExit = (exit: Exit.Exit<any, E>) => {
-          if (exit._tag === 'Failure' && Cause.isInterruptedOnly(exit.cause) === false) {
-            // Deferred.unsafeDone(closeLatch, Exit.die(Cause.squash(exit.cause)))
-            Deferred.unsafeDone(closeLatch, Exit.die(exit.cause))
-          }
-        }
-         port.on('message', (message: RunnerMessage<I>) => {
-          // console.log('message', message)
-
-          // Handle parent death detection setup messages
-          if (isSetupParentDeathDetectionMessage(message) === true) {
-            const parentPid = message[1].parentPid
-            // console.log(`[Worker ${process.pid}] Setting up parent death detection for parent ${parentPid}`)
-            setupParentDeathMonitoring(parentPid)
-            return
-          }
-
-          // Handle normal Effect worker messages
-          if (Array.isArray(message) === true && typeof message[0] === 'number') {
-            if (message[0] === 0) {
-              const result = handler(0, message[1])
-              if (Effect.isEffect(result) === true) {
-                const fiber = runFork(result)
-                fiber.addObserver(onExit)
-                FiberSet.unsafeAdd(fiberSet, fiber)
-              }
-            } else {
-              // Graceful shutdown requested by parent: stop monitoring and close port
-              stopParentDeathMonitoring()
-              Deferred.unsafeDone(closeLatch, Exit.void)
-              port.close()
-            }
-          }
-        })
-        port.on('messageerror', (cause) => {
-          Deferred.unsafeDone(closeLatch, new WorkerError({ reason: 'decode', cause }))
-        })
-        port.on('error', (cause) => {
-          Deferred.unsafeDone(closeLatch, new WorkerError({ reason: 'unknown', cause }))
-        })
-        port.postMessage([0])
-      })
-
-      return { run, send }
-    })
-  },
-})
-
-export const layer = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/ChildProcessRunner.test.ts

@@ -1,311 +0,0 @@
-import * as ChildProcess from 'node:child_process'
-
-import * as EffectWorker from '@effect/platform/Worker'
-import { assert, describe, it } from '@effect/vitest'
-import { Chunk, Deferred, Effect, Exit, Fiber, Schema, Scope, Stream } from 'effect'
-
-export class TestError extends Schema.TaggedError<TestError>()('TestError', {
-  message: Schema.String,
-}) {}
-
-import * as ChildProcessWorker from '../ChildProcessWorker.ts'
-import type { WorkerMessage } from './schema.ts'
-import { GetPersonById, GetUserById, InitialMessage, Person, StartStubbornWorker, User } from './schema.ts'
-
-const WorkerLive = ChildProcessWorker.layer(() =>
-  ChildProcess.fork(
-    new URL('../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js', import.meta.url),
-  ),
-)
-
-// const WorkerLive = NodeWorker.layer(
-//   () =>
-//     new WorkerThreads.Worker(
-//       new URL('../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js', import.meta.url),
-//     ),
-// )
-
-describe('ChildProcessRunner', { timeout: 10_000 }, () => {
-  it('Serialized', () =>
-    Effect.gen(function* () {
-      const pool = yield* EffectWorker.makePoolSerialized({ size: 1 })
-      const people = yield* pool.execute(new GetPersonById({ id: 123 })).pipe(Stream.runCollect)
-      assert.deepStrictEqual(Chunk.toReadonlyArray(people), [
-        new Person({ id: 123, name: 'test', data: new Uint8Array([1, 2, 3]) }),
-        new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
-      ])
-    }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
-
-  it('Serialized with initialMessage', () =>
-    Effect.gen(function* () {
-      const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
-        size: 1,
-        initialMessage: () => new InitialMessage({ name: 'custom', data: new Uint8Array([1, 2, 3]) }),
-      })
-
-      let user = yield* pool.executeEffect(new GetUserById({ id: 123 }))
-      user = yield* pool.executeEffect(new GetUserById({ id: 123 }))
-      assert.deepStrictEqual(user, new User({ id: 123, name: 'custom' }))
-      const people = yield* pool.execute(new GetPersonById({ id: 123 })).pipe(Stream.runCollect)
-      assert.deepStrictEqual(Chunk.toReadonlyArray(people), [
-        new Person({ id: 123, name: 'test', data: new Uint8Array([1, 2, 3]) }),
-        new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
-      ])
-    }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
-
-  describe('Process Cleanup', { timeout: 15_000 }, () => {
-    const isProcessRunning = (pid: number) => {
-      try {
-        process.kill(pid, 0) // Signal 0 checks if process exists
-        return true
-      } catch {
-        return false
-      }
-    }
-
-    it('should clean up child processes when Effect is interrupted', () =>
-      Effect.gen(function* () {
-        const workerPidDeferred = yield* Deferred.make<number>()
-
-        const testEffect = Effect.gen(function* () {
-          const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
-            size: 1,
-            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
-          })
-          const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 }))
-          yield* Deferred.succeed(workerPidDeferred, result.pid)
-
-          // Verify the worker process is running
-          assert.strictEqual(isProcessRunning(result.pid), true, 'Worker process should be running')
-
-          // Start a long-running operation that we'll interrupt
-          yield* Effect.sleep('60 seconds')
-        }).pipe(Effect.scoped, Effect.provide(WorkerLive))
-
-        // Run the test effect but interrupt it after 2 seconds
-        const fiber = yield* Effect.forkScoped(testEffect)
-
-        const workerPid = yield* Deferred.await(workerPidDeferred).pipe(
-          Effect.raceFirst(
-            Fiber.join(fiber).pipe(
-              Effect.flatMap(() => new TestError({ message: 'testEffect completed before reporting worker PID' })),
-            ),
-          ),
-          Effect.timeout(10_000),
-        )
-
-        yield* Effect.sleep('2 seconds')
-        yield* Fiber.interrupt(fiber)
-
-        // Wait a moment for cleanup to complete
-        yield* Effect.sleep('1 second')
-
-        assert.strictEqual(
-          isProcessRunning(workerPid),
-          false,
-          `Worker process ${workerPid} should be terminated after Effect interruption`,
-        )
-      }).pipe(Effect.scoped, Effect.runPromise))
-
-    it('should clean up child processes when scope is closed abruptly', () =>
-      Effect.gen(function* () {
-        let workerPid: number | undefined
-
-        // Create a scope that we can close manually
-        const scope = yield* Scope.make()
-
-        try {
-          const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
-            size: 1,
-            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
-          }).pipe(Scope.extend(scope), Effect.provide(WorkerLive))
-
-          const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 }))
-          workerPid = result.pid
-
-          // Verify the worker is running
-          assert.strictEqual(isProcessRunning(workerPid), true, 'Worker process should be running')
-        } finally {
-          // Abruptly close the scope (simulating test abortion)
-          yield* Scope.close(scope, Exit.void)
-        }
-
-        // Wait for cleanup
-        yield* Effect.sleep('1 second')
-
-        // This should pass but will initially fail due to zombie process issue
-        if (workerPid !== undefined) {
-          assert.strictEqual(
-            isProcessRunning(workerPid),
-            false,
-            `Worker process ${workerPid} should be terminated after scope closure`,
-          )
-        } else {
-          assert.fail('Worker PID was not captured')
-        }
-      }).pipe(Effect.runPromise))
-
-    it('should clean up child processes when parent receives SIGINT', () =>
-      Effect.gen(function* () {
-        let workerPid: number | undefined
-
-        const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
-          size: 1,
-          initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
-        })
-
-        const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 60_000 }))
-        workerPid = result.pid
-
-        // Verify the worker is running
-        assert.strictEqual(isProcessRunning(workerPid), true, 'Worker process should be running')
-
-        // Simulate SIGINT being sent to current process (like Ctrl+C in vitest)
-        // This should trigger cleanup of child processes
-        yield* Effect.async<void>((resume) => {
-          // Store current listeners before we manipulate them
-          const currentSIGINTListeners = process.listeners('SIGINT').slice()
-
-          // Set up our test handler
-          const testHandler = () => {
-            // Emit SIGINT to all current listeners to trigger cleanup
-            currentSIGINTListeners.forEach((listener) => {
-              try {
-                ;(listener as Function)()
-              } catch {
-                // Ignore errors
-              }
-            })
-            resume(Effect.void)
-          }
-
-          // Remove all current SIGINT listeners and add our test handler
-          process.removeAllListeners('SIGINT')
-          process.once('SIGINT', testHandler)
-
-          // Send SIGINT after a short delay
-          setTimeout(() => {
-            process.kill(process.pid, 'SIGINT')
-          }, 1000)
-        })
-
-        // Wait for cleanup to complete
-        yield* Effect.sleep('2 seconds')
-
-        // This test should initially fail - child process will still be running
-        if (workerPid !== undefined) {
-          assert.strictEqual(
-            isProcessRunning(workerPid),
-            false,
-            `Worker process ${workerPid} should be terminated after SIGINT`,
-          )
-        } else {
-          assert.fail('Worker PID was not captured')
-        }
-      }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
-
-    it('should clean up multiple concurrent child processes', () =>
-      Effect.gen(function* () {
-        let workerPids: number[] = []
-
-        const testEffect = Effect.gen(function* () {
-          const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
-            size: 3, // Multiple workers
-            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
-          })
-
-          // Start multiple stubborn workers
-          const workers = yield* Effect.all(
-            [
-              pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 })),
-              pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 })),
-              pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 })),
-            ],
-            { concurrency: 'unbounded' },
-          )
-
-          workerPids = workers.map((w) => w.pid)
-
-          // Verify all workers are running
-          for (const pid of workerPids) {
-            assert.strictEqual(isProcessRunning(pid), true, `Worker process ${pid} should be running`)
-          }
-
-          yield* Effect.sleep('30 seconds') // Keep running until interrupted
-        }).pipe(Effect.scoped, Effect.provide(WorkerLive))
-
-        // Run with timeout to force termination
-        const fiber = yield* Effect.fork(testEffect)
-        yield* Effect.sleep('2 seconds')
-        yield* Fiber.interrupt(fiber)
-
-        // Wait for cleanup
-        yield* Effect.sleep('2 seconds')
-
-        // All worker processes should be cleaned up
-        for (const pid of workerPids) {
-          assert.strictEqual(
-            isProcessRunning(pid),
-            false,
-            `Worker process ${pid} should be terminated after pool cleanup`,
-          )
-        }
-      }).pipe(Effect.runPromise))
-
-    it('should handle direct ChildProcess.fork cleanup (node-sync pattern)', () =>
-      Effect.gen(function* () {
-        let childPid: number | undefined
-
-        // This mimics the exact pattern used in node-sync tests
-        const nodeChildProcess = ChildProcess.fork(
-          new URL(
-            '../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js',
-            import.meta.url,
-          ),
-          ['test-client'],
-        )
-
-        childPid = nodeChildProcess.pid
-
-        const testEffect = Effect.gen(function* () {
-          const worker = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
-            size: 1,
-            concurrency: 100,
-            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
-          }).pipe(Effect.provide(ChildProcessWorker.layer(() => nodeChildProcess)))
-
-          // Start stubborn worker
-          yield* worker.executeEffect(new StartStubbornWorker({ blockDuration: 60_000 }))
-
-          // Verify process is running
-          if (childPid !== undefined) {
-            assert.strictEqual(isProcessRunning(childPid), true, 'Child process should be running')
-          }
-
-          // Keep running until interrupted
-          yield* Effect.sleep('30 seconds')
-        }).pipe(Effect.scoped)
-
-        // Simulate the exact abortion pattern from node-sync
-        const fiber = yield* Effect.fork(testEffect)
-        yield* Effect.sleep('2 seconds')
-
-        // Force kill the fiber without proper cleanup (simulates Ctrl+C)
-        yield* Fiber.interrupt(fiber)
-
-        // Wait for cleanup
-        yield* Effect.sleep('3 seconds')
-
-        // This test should initially fail - demonstrating the zombie process issue
-        if (childPid !== undefined) {
-          assert.strictEqual(
-            isProcessRunning(childPid),
-            false,
-            `Child process ${childPid} should be terminated after forced interruption`,
-          )
-        } else {
-          assert.fail('Child PID was not captured')
-        }
-      }).pipe(Effect.runPromise))
-  })
-})

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/schema.ts

@@ -1,78 +0,0 @@
-// import * as Transferable from '@effect/platform/Transferable'
-import * as Schema from 'effect/Schema'
-
-export class User extends Schema.Class<User>('User')({
-  id: Schema.Number,
-  name: Schema.String,
-}) {}
-
-export class GetUserById extends Schema.TaggedRequest<GetUserById>()('GetUserById', {
-  failure: Schema.Never,
-  success: User,
-  payload: {
-    id: Schema.Number,
-  },
-}) {}
-
-export class Person extends Schema.Class<Person>('Person')({
-  id: Schema.Number,
-  name: Schema.String,
-  // data: Transferable.Uint8Array,
-  data: Schema.Uint8Array,
-}) {}
-
-export class GetPersonById extends Schema.TaggedRequest<GetPersonById>()('GetPersonById', {
-  failure: Schema.Never,
-  success: Person,
-  payload: {
-    id: Schema.Number,
-  },
-}) {}
-
-export class RunnerInterrupt extends Schema.TaggedRequest<RunnerInterrupt>()('RunnerInterrupt', {
-  failure: Schema.Never,
-  success: Schema.Void,
-  payload: {},
-}) {}
-
-export class StartStubbornWorker extends Schema.TaggedRequest<StartStubbornWorker>()('StartStubbornWorker', {
-  failure: Schema.Never,
-  success: Schema.Struct({ pid: Schema.Number }),
-  payload: { blockDuration: Schema.Number },
-}) {}
-
-export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
-  failure: Schema.Never,
-  success: Schema.Void,
-  payload: {
-    name: Schema.String,
-    data: Schema.Uint8Array,
-    // data: Transferable.Uint8Array,
-  },
-}) {}
-
-export class GetSpan extends Schema.TaggedRequest<GetSpan>()('GetSpan', {
-  failure: Schema.Never,
-  success: Schema.Struct({
-    name: Schema.String,
-    traceId: Schema.String,
-    spanId: Schema.String,
-    parent: Schema.Option(
-      Schema.Struct({
-        traceId: Schema.String,
-        spanId: Schema.String,
-      }),
-    ),
-  }),
-  payload: {},
-}) {}
-
-export const WorkerMessage = Schema.Union(
-  GetUserById,
-  GetPersonById,
-  InitialMessage,
-  GetSpan,
-  RunnerInterrupt,
-  StartStubbornWorker,
-)
-export type WorkerMessage = Schema.Schema.Type<typeof WorkerMessage>

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.ts

@@ -1,65 +0,0 @@
-import * as Runner from '@effect/platform/WorkerRunner'
-import { Context, Effect, Layer, Option, Stream } from 'effect'
-
-// import { NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
-import { PlatformNode } from '../../mod.ts'
-import * as ChildProcessRunner from '../ChildProcessRunner.ts'
-import { Person, User, WorkerMessage } from './schema.ts'
-
-interface Name {
-  readonly _: unique symbol
-}
-const Name = Context.GenericTag<Name, string>('Name')
-
-const WorkerLive = Runner.layerSerialized(WorkerMessage, {
-  GetPersonById: (req) => {
-    return Stream.make(
-      new Person({ id: req.id, name: 'test', data: new Uint8Array([1, 2, 3]) }),
-      new Person({ id: req.id, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
-    )
-  },
-  GetUserById: (req) => Effect.map(Name, (name) => new User({ id: req.id, name })),
-  // InitialMessage: (req) => Layer.succeed(Name, req.name),
-  InitialMessage: (req) =>
-    Effect.gen(function* () {
-      // yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
-      return Layer.succeed(Name, req.name)
-    }).pipe(Layer.unwrapScoped),
-  // InitialMessage: (req) =>
-  //   Layer.scoped(
-  //     Name,
-  //     Effect.gen(function* () {
-  //       yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
-  //       return req.name
-  //     }),
-  //   ),
-  GetSpan: Effect.fn('GetSpan')(function* (_) {
-    const span = yield* Effect.currentSpan.pipe(Effect.orDie)
-    return {
-      traceId: span.traceId,
-      spanId: span.spanId,
-      name: span.name,
-      parent: Option.map(span.parent, (span) => ({
-        traceId: span.traceId,
-        spanId: span.spanId,
-      })),
-    }
-  }),
-  RunnerInterrupt: () => Effect.interrupt,
-  StartStubbornWorker: ({ blockDuration }) =>
-    Effect.gen(function* () {
-      // Start a blocking operation that won't respond to normal shutdown signals
-      const pid = process.pid
-      yield* Effect.fork(
-        Effect.gen(function* () {
-          // Block for the specified duration, ignoring shutdown attempts
-          yield* Effect.sleep(`${blockDuration} millis`)
-          yield* Effect.log('Stubborn worker finished blocking')
-        }).pipe(Effect.uninterruptible),
-      )
-      return { pid }
-    }),
-}).pipe(Layer.provide(ChildProcessRunner.layer))
-// }).pipe(Layer.provide(PlatformNode.NodeWorkerRunner.layer))
-
-PlatformNode.NodeRuntime.runMain(Runner.launch(WorkerLive))