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

package/src/node/DockerComposeService/DockerComposeService.ts

@@ -0,0 +1,252 @@
+import { omitUndefineds } from '@livestore/utils'
+import {
+  Command,
+  type CommandExecutor,
+  Duration,
+  Effect,
+  type PlatformError,
+  Schedule,
+  Schema,
+  type Scope,
+  Stream,
+} from '@livestore/utils/effect'
+
+export class DockerComposeError extends Schema.TaggedError<DockerComposeError>()('DockerComposeError', {
+  cause: Schema.Defect,
+  message: 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 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}`)
+
+        yield* Command.make('docker', 'compose', 'pull').pipe(
+          Command.workingDirectory(cwd),
+          Command.exitCode,
+          Effect.flatMap((exitCode: number) =>
+            exitCode === 0
+              ? Effect.void
+              : Effect.fail(
+                  new DockerComposeError({
+                    cause: new Error(`Docker compose pull failed with exit code ${exitCode}`),
+                    message: `Docker compose pull failed with exit code ${exitCode}`,
+                  }),
+                ),
+          ),
+          Effect.provide(commandExecutorContext),
+        )
+
+        yield* Effect.log(`Successfully pulled Docker Compose images`)
+      }).pipe(Effect.withSpan('pullDockerComposeImages'))
+
+      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.start,
+            Effect.catchAll((cause) =>
+              Effect.fail(
+                new DockerComposeError({
+                  cause,
+                  message: `Failed to start Docker Compose services in ${cwd}`,
+                }),
+              ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          // Wait for command completion
+          yield* command.exitCode.pipe(
+            Effect.flatMap((exitCode: number) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose exited with code ${exitCode}`),
+                      message: `Docker Compose failed to start with exit code ${exitCode}`,
+                    }),
+                  ),
+            ),
+            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}`),
+                    message: `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,
+                  message: `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,
+                  message: `Error reading Docker Compose logs in ${cwd}`,
+                }),
+            ),
+          )
+        }).pipe(Stream.unwrapScoped)
+
+      return { pull, start, stop, 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'),
+            message: `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
+  })
+}