@livestore/utils-dev 0.0.0-snapshot-9d8807d2c51c95b4df3556744702cea55dc7ded3 → 0.0.0-snapshot-764973e035e7322a3936e1c79f2e78820e04f73c

package/package.json

@@ -1,34 +1,28 @@
 {
   "name": "@livestore/utils-dev",
-  "version": "0.0.0-snapshot-9d8807d2c51c95b4df3556744702cea55dc7ded3",
+  "version": "0.0.0-snapshot-764973e035e7322a3936e1c79f2e78820e04f73c",
   "type": "module",
   "sideEffects": [
-    "./dist/node-vitest/polyfill.js"
+    "./src/node-vitest/global.ts",
+    "./dist/node-vitest/global.js"
   ],
   "exports": {
-    "./node": {
-      "types": "./dist/node/mod.d.ts",
-      "default": "./dist/node/mod.js"
-    },
-    "./node-vitest": {
-      "types": "./dist/node-vitest/mod.d.ts",
-      "default": "./dist/node-vitest/mod.js"
-    },
-    "./node-vitest-polyfill": {
-      "types": "./dist/node-vitest/polyfill.d.ts",
-      "default": "./dist/node-vitest/polyfill.js"
-    }
+    "./node": "./dist/node/mod.js",
+    "./node-vitest": "./dist/node-vitest/mod.js",
+    "./wrangler": "./dist/wrangler/mod.js"
   },
   "dependencies": {
-    "@effect/opentelemetry": "0.48.4",
-    "@effect/vitest": "0.22.2",
+    "@effect/opentelemetry": "0.58.0",
+    "@effect/vitest": "0.26.0",
+    "@iarna/toml": "2.2.5",
     "@opentelemetry/api": "1.9.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "0.200.0",
-    "@opentelemetry/exporter-trace-otlp-http": "0.200.0",
-    "@opentelemetry/sdk-metrics": "2.0.0",
-    "@opentelemetry/sdk-trace-base": "2.0.0",
-    "@opentelemetry/sdk-trace-node": "2.0.0",
-    "@livestore/utils": "0.0.0-snapshot-9d8807d2c51c95b4df3556744702cea55dc7ded3"
+    "@opentelemetry/exporter-metrics-otlp-http": "0.203.0",
+    "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
+    "@opentelemetry/sdk-metrics": "2.0.1",
+    "@opentelemetry/sdk-trace-base": "2.0.1",
+    "@opentelemetry/sdk-trace-node": "2.0.1",
+    "wrangler": "4.42.2",
+    "@livestore/utils": "0.0.0-snapshot-764973e035e7322a3936e1c79f2e78820e04f73c"
   },
   "devDependencies": {},
   "files": [

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,328 @@
+import { omitUndefineds } from '@livestore/utils'
+import {
+  Command,
+  type CommandExecutor,
+  Duration,
+  Effect,
+  Fiber,
+  type PlatformError,
+  Schedule,
+  Schema,
+  type Scope,
+  Stream,
+} from '@livestore/utils/effect'
+
+export class DockerComposeError extends Schema.TaggedError<DockerComposeError>()('DockerComposeError', {
+  cause: Schema.Defect,
+  note: 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 down: (options?: {
+    readonly env?: Record<string, string>
+    readonly volumes?: boolean
+    readonly removeOrphans?: boolean
+  }) => 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}`)
+
+        // TODO (@IMax153) Refactor the effect command related code below as there is probably a much more elegant way to accomplish what we want here in a more effect idiomatic way.
+        const pullCommand = Command.make('docker', 'compose', 'pull').pipe(
+          Command.workingDirectory(cwd),
+          Command.stdout('pipe'),
+          Command.stderr('pipe'),
+        )
+
+        const process = yield* pullCommand.pipe(Command.start, Effect.provide(commandExecutorContext))
+
+        const stdoutFiber = yield* process.stdout.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runFold('', (acc, chunk) => acc + chunk),
+          Effect.fork,
+        )
+
+        const stderrFiber = yield* process.stderr.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runFold('', (acc, chunk) => acc + chunk),
+          Effect.fork,
+        )
+
+        const exitCode = yield* process.exitCode
+        const stdout = yield* Fiber.join(stdoutFiber)
+        const stderr = yield* Fiber.join(stderrFiber)
+
+        const exitCodeNumber = Number(exitCode)
+
+        if (exitCodeNumber !== 0) {
+          const stdoutLog = stdout.length > 0 ? stdout : '<empty stdout>'
+          const stderrLog = stderr.length > 0 ? stderr : '<empty stderr>'
+          const failureMessage = [
+            `Docker compose pull failed with exit code ${exitCodeNumber} in ${cwd}`,
+            `stdout:\n${stdoutLog}`,
+            `stderr:\n${stderrLog}`,
+          ].join('\n')
+
+          yield* Effect.logError(failureMessage)
+
+          return yield* new DockerComposeError({
+            cause: new Error(`Docker compose pull failed with exit code ${exitCodeNumber}`),
+            note: failureMessage,
+          })
+        }
+
+        yield* Effect.log(`Successfully pulled Docker Compose images`)
+      }).pipe(
+        Effect.retry({
+          schedule: Schedule.exponentialBackoff10Sec,
+          while: Schema.is(DockerComposeError),
+        }),
+        Effect.withSpan('pullDockerComposeImages'),
+        Effect.scoped,
+      )
+
+      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.stderr('inherit'),
+            Command.stdout('inherit'),
+            Command.start,
+            Effect.catchAll((cause) =>
+              Effect.fail(
+                new DockerComposeError({
+                  cause,
+                  note: `Failed to start Docker Compose services in ${cwd}`,
+                }),
+              ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          // Wait for command completion
+          yield* command.exitCode.pipe(
+            Effect.flatMap((exitCode) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose exited with code ${exitCode}`),
+                      note: `Docker Compose failed to start with exit code ${exitCode}. Env: ${JSON.stringify(options.env)}`,
+                    }),
+                  ),
+            ),
+            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}`),
+                    note: `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,
+                  note: `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,
+                  note: `Error reading Docker Compose logs in ${cwd}`,
+                }),
+            ),
+          )
+        }).pipe(Stream.unwrapScoped)
+
+      const down = (options?: {
+        readonly env?: Record<string, string>
+        readonly volumes?: boolean
+        readonly removeOrphans?: boolean
+      }) =>
+        Effect.gen(function* () {
+          yield* Effect.log(`Tearing down Docker Compose services in ${cwd}`)
+
+          const baseArgs = ['docker', 'compose', 'down']
+          if (options?.volumes) baseArgs.push('-v')
+          if (options?.removeOrphans) baseArgs.push('--remove-orphans')
+          if (serviceName) baseArgs.push(serviceName)
+
+          yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.env(options?.env ?? {}),
+            Command.exitCode,
+            Effect.flatMap((exitCode: number) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose down exited with code ${exitCode}`),
+                      note: `Failed to tear down Docker Compose services`,
+                    }),
+                  ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          yield* Effect.log(`Docker Compose services torn down successfully`)
+        }).pipe(Effect.withSpan('downDockerCompose'))
+
+      return { pull, start, stop, down, 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'),
+            note: `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/FileLogger.ts

@@ -0,0 +1,206 @@
+import * as fs from 'node:fs'
+import path from 'node:path'
+import util from 'node:util'
+import {
+  Cause,
+  Effect,
+  FiberId,
+  HashMap,
+  Inspectable,
+  Layer,
+  List,
+  Logger,
+  type LogLevel,
+  LogSpan,
+  ReadonlyArray,
+} from '@livestore/utils/effect'
+
+export const makeFileLogger = (
+  logFilePath: string,
+  options?: {
+    readonly threadName: string
+    readonly colors?: boolean
+  },
+) =>
+  Layer.unwrapScoped(
+    Effect.gen(function* () {
+      yield* Effect.sync(() => fs.mkdirSync(path.dirname(logFilePath), { recursive: true }))
+
+      const logFile = yield* Effect.acquireRelease(
+        Effect.sync(() => fs.openSync(logFilePath, 'a', 0o666)),
+        (fd) => Effect.sync(() => fs.closeSync(fd)),
+      )
+
+      return Logger.replace(
+        Logger.defaultLogger,
+        prettyLoggerTty({
+          colors: options?.colors ?? false,
+          stderr: false,
+          formatDate: (date) => `${defaultDateFormat(date)} ${options?.threadName ?? ''}`,
+          onLog: (str) => fs.writeSync(logFile, str),
+        }),
+      )
+    }),
+  )
+
+const withColor = (text: string, ...colors: ReadonlyArray<string>) => {
+  let out = ''
+  for (let i = 0; i < colors.length; i++) {
+    out += `\x1b[${colors[i]}m`
+  }
+  return `${out}${text}\x1b[0m`
+}
+const withColorNoop = (text: string, ..._colors: ReadonlyArray<string>) => text
+
+const colors = {
+  bold: '1',
+  red: '31',
+  green: '32',
+  yellow: '33',
+  blue: '34',
+  cyan: '36',
+  white: '37',
+  gray: '90',
+  black: '30',
+  bgBrightRed: '101',
+} as const
+
+const logLevelColors: Record<LogLevel.LogLevel['_tag'], ReadonlyArray<string>> = {
+  None: [],
+  All: [],
+  Trace: [colors.gray],
+  Debug: [colors.blue],
+  Info: [colors.green],
+  Warning: [colors.yellow],
+  Error: [colors.red],
+  Fatal: [colors.bgBrightRed, colors.black],
+}
+
+export const defaultDateFormat = (date: Date): string =>
+  `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date
+    .getSeconds()
+    .toString()
+    .padStart(2, '0')}.${date.getMilliseconds().toString().padStart(3, '0')}`
+
+export const structuredMessage = (u: unknown): unknown => {
+  switch (typeof u) {
+    case 'bigint':
+    case 'function':
+    case 'symbol': {
+      return String(u)
+    }
+    default: {
+      return Inspectable.toJSON(u)
+    }
+  }
+}
+
+const consoleLogToString = (...s: any[]) => {
+  if (s.length === 0) return ''
+  const [first, ...rest] = s
+  if (typeof first === 'string') {
+    return rest.length > 0 ? util.format(first, ...rest.map(structuredMessage)) : first
+  }
+  return s
+    .map((v) => {
+      if (typeof v === 'string') return v
+      return util.inspect(structuredMessage(v), {
+        depth: 3,
+        colors: false,
+        compact: false,
+        breakLength: 120,
+      })
+    })
+    .join(' ')
+}
+
+export const prettyLoggerTty = (options: {
+  readonly colors: boolean
+  readonly stderr: boolean
+  readonly formatDate: (date: Date) => string
+  readonly onLog?: (str: string) => void
+}) => {
+  const color = options.colors ? withColor : withColorNoop
+  return Logger.make<unknown, string>(({ annotations, cause, date, fiberId, logLevel, message: message_, spans }) => {
+    let str = ''
+
+    const log = (...s: any[]) => {
+      str += `${consoleLogToString(...s)}\n`
+      options.onLog?.(str)
+    }
+
+    const logIndented = (...s: any[]) => {
+      str += `${consoleLogToString(...s).replace(/^/gm, '  ')}\n`
+      options.onLog?.(str)
+    }
+
+    const message = ReadonlyArray.ensure(message_)
+
+    let firstLine =
+      color(`[${options.formatDate(date)}]`, colors.white) +
+      ` ${color(logLevel.label, ...logLevelColors[logLevel._tag])}` +
+      ` (${FiberId.threadName(fiberId)})`
+
+    if (List.isCons(spans)) {
+      const now = date.getTime()
+      const render = LogSpan.render(now)
+      for (const span of spans) {
+        firstLine += ` ${render(span)}`
+      }
+    }
+
+    firstLine += ':'
+    let messageIndex = 0
+    if (message.length > 0) {
+      const firstMaybeString = structuredMessage(message[0])
+      if (typeof firstMaybeString === 'string') {
+        firstLine += ` ${color(firstMaybeString, colors.bold, colors.cyan)}`
+        messageIndex++
+      }
+    }
+
+    log(firstLine)
+    // if (!processIsBun) console.group()
+
+    if (!Cause.isEmpty(cause)) {
+      logIndented(Cause.pretty(cause, { renderErrorCause: true }))
+    }
+
+    if (messageIndex < message.length) {
+      for (; messageIndex < message.length; messageIndex++) {
+        const msg = message[messageIndex]
+        if (typeof msg === 'object' && msg !== null) {
+          logIndented(
+            util.inspect(structuredMessage(msg), {
+              depth: 3,
+              colors: false,
+              compact: false,
+              breakLength: 120,
+            }),
+          )
+        } else {
+          logIndented(Inspectable.redact(msg))
+        }
+      }
+    }
+
+    if (HashMap.size(annotations) > 0) {
+      for (const [key, value] of annotations) {
+        const formattedValue =
+          typeof value === 'object' && value !== null
+            ? util.inspect(structuredMessage(value), {
+                depth: 3,
+                colors: false,
+                compact: false,
+                breakLength: 120,
+              })
+            : Inspectable.redact(value)
+        logIndented(color(`${key}:`, colors.bold, colors.white), formattedValue)
+      }
+    }
+
+    // if (!processIsBun) console.groupEnd()
+
+    return str
+  })
+}