@livestore/utils-dev 0.4.0 → 0.5.0-dev.0

package/src/node/DockerCompose/DockerCompose.ts

@@ -0,0 +1,328 @@
+import { objectToString, omitUndefineds } from '@livestore/utils'
+import {
+  ChildProcess,
+  ChildProcessSpawner,
+  Context,
+  Duration,
+  Effect,
+  Fiber,
+  Layer,
+  type PlatformError,
+  Schedule,
+  Schema,
+  type Scope,
+  Stream,
+} from '@livestore/utils/effect'
+
+export class DockerComposeError extends Schema.TaggedError<DockerComposeError>(
+  '~@livestore/utils-dev/DockerComposeError',
+)('DockerComposeError', {
+  cause: Schema.Defect(),
+  note: Schema.String,
+  /** Compose env of the failed invocation, if any — structured instead of string-formatted into `note`. */
+  env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+}) {}
+
+export interface Options {
+  readonly cwd: string
+  readonly serviceName?: string
+  /** Unique project name to isolate this compose instance. If not provided, a random one is generated. */
+  readonly projectName?: 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 Service {
+  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>
+  /** The unique project name used to isolate this compose instance */
+  readonly projectName: string
+}
+
+const generateProjectName = (): string => `ls-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+
+export class DockerCompose extends Context.Service<DockerCompose, Service>()('@livestore/utils-dev/DockerCompose') {}
+
+export const make = (args: Options) =>
+  Effect.gen(function* () {
+    const { cwd, serviceName } = args
+    const projectName = args.projectName ?? generateProjectName()
+
+    const commandExecutorContext = yield* Effect.context<ChildProcessSpawner.ChildProcessSpawner>()
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+    const baseComposeArgs = ['-p', projectName]
+
+    const composeCommand = (args: ReadonlyArray<string>, options: ChildProcess.CommandOptions = {}) =>
+      ChildProcess.make('docker', ['compose', ...baseComposeArgs, ...args], { ...options, cwd })
+
+    const envOptions = (
+      env: Record<string, string> | undefined,
+    ): Pick<ChildProcess.CommandOptions, 'env' | 'extendEnv'> => (env === undefined ? {} : { env, extendEnv: true })
+
+    const pull = Effect.gen(function* () {
+      yield* Effect.log(`Pulling Docker Compose images in ${cwd}`)
+
+      const process = yield* spawner.spawn(composeCommand(['pull'], { stdout: 'pipe', stderr: 'pipe' }))
+
+      const stdoutFiber = yield* process.stdout.pipe(
+        Stream.decodeText({ encoding: 'utf8' }),
+        Stream.runFold(
+          () => '',
+          (acc, chunk) => acc + chunk,
+        ),
+        // Drain subprocess output immediately so the child cannot block while we wait for its exit code.
+        Effect.forkChild,
+      )
+
+      const stderrFiber = yield* process.stderr.pipe(
+        Stream.decodeText({ encoding: 'utf8' }),
+        Stream.runFold(
+          () => '',
+          (acc, chunk) => acc + chunk,
+        ),
+        // Drain subprocess output immediately so the child cannot block while we wait for its exit code.
+        Effect.forkChild,
+      )
+
+      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 = Effect.fn('startDockerCompose')(function* (options: StartOptions = {}) {
+      const { detached = true, healthCheck } = options
+
+      const startArgs = ['up']
+      if (detached === true) startArgs.push('-d')
+      if (serviceName !== undefined) startArgs.push(serviceName)
+
+      const process = yield* spawner
+        .spawn(composeCommand(startArgs, { ...envOptions(options.env), stderr: 'inherit', stdout: 'inherit' }))
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new DockerComposeError({
+                cause,
+                note: `Failed to start Docker Compose services in ${cwd}`,
+              }),
+          ),
+        )
+
+      const exitCode = yield* process.exitCode
+
+      if (Number(exitCode) !== 0) {
+        return yield* new DockerComposeError({
+          cause: new Error(`Docker compose exited with code ${exitCode}`),
+          note: `Docker Compose failed to start with exit code ${exitCode}`,
+          env: options.env,
+        })
+      }
+
+      if (healthCheck !== undefined) {
+        yield* performHealthCheck(healthCheck).pipe(Effect.provide(commandExecutorContext))
+      }
+
+      yield* Effect.log(`Docker Compose services started successfully in ${cwd}`)
+    })
+
+    const stop = Effect.gen(function* () {
+      yield* Effect.log(`Stopping Docker Compose services in ${cwd}`)
+
+      const stopArgs = serviceName === undefined ? ['stop'] : ['stop', serviceName]
+      const exitCode = yield* spawner.exitCode(composeCommand(stopArgs))
+
+      if (Number(exitCode) !== 0) {
+        return yield* new DockerComposeError({
+          cause: new Error(`Docker compose stop exited with code ${exitCode}`),
+          note: `Failed to stop Docker Compose services`,
+        })
+      }
+
+      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 logsArgs = ['logs']
+        if (follow === true) logsArgs.push('-f')
+        if (tail !== undefined) logsArgs.push('--tail', tail.toString())
+        if (since !== undefined) logsArgs.push('--since', since)
+        if (serviceName !== undefined) logsArgs.push(serviceName)
+
+        const process = yield* spawner.spawn(composeCommand(logsArgs)).pipe(
+          Effect.mapError(
+            (cause) =>
+              new DockerComposeError({
+                cause,
+                note: `Failed to read Docker Compose logs in ${cwd}`,
+              }),
+          ),
+        )
+
+        return process.stdout.pipe(
+          Stream.decodeText({ encoding: 'utf8' }),
+          Stream.splitLines,
+          Stream.mapError(
+            (cause) =>
+              new DockerComposeError({
+                cause,
+                note: `Error reading Docker Compose logs in ${cwd}`,
+              }),
+          ),
+        )
+      }).pipe(Stream.unwrap)
+
+    const down = Effect.fn('downDockerCompose')(function* (options?: {
+      readonly env?: Record<string, string>
+      readonly volumes?: boolean
+      readonly removeOrphans?: boolean
+    }) {
+      yield* Effect.log(`Tearing down Docker Compose services in ${cwd}`)
+
+      const downArgs = ['down']
+      if (options?.volumes === true) downArgs.push('-v')
+      if (options?.removeOrphans === true) downArgs.push('--remove-orphans')
+      if (serviceName !== undefined) downArgs.push(serviceName)
+
+      const exitCode = yield* spawner.exitCode(composeCommand(downArgs, envOptions(options?.env)))
+
+      if (Number(exitCode) !== 0) {
+        return yield* new DockerComposeError({
+          cause: new Error(`Docker compose down exited with code ${exitCode}`),
+          note: `Failed to tear down Docker Compose services`,
+        })
+      }
+
+      yield* Effect.log(`Docker Compose services torn down successfully`)
+    })
+
+    // Register cleanup finalizer to ensure containers are removed when scope closes
+    yield* Effect.addFinalizer(() =>
+      down({ volumes: true, removeOrphans: true }).pipe(
+        Effect.tap(() => Effect.log(`Docker Compose cleanup completed for project ${projectName}`)),
+        Effect.catchCause((cause) =>
+          Effect.log('Docker Compose cleanup failed for project', projectName, objectToString(cause)),
+        ),
+      ),
+    )
+
+    return DockerCompose.of({ pull, start, stop, down, logs, projectName })
+  })
+
+export const layer = (options: Options) => Layer.effect(DockerCompose, make(options))
+
+const performHealthCheck = ({
+  url,
+  timeout = Duration.minutes(2),
+  interval = Duration.seconds(2),
+}: {
+  url: string
+  timeout?: Duration.Duration
+  interval?: Duration.Duration
+}): Effect.Effect<void, DockerComposeError, ChildProcessSpawner.ChildProcessSpawner | Scope.Scope> =>
+  Effect.gen(function* () {
+    yield* Effect.log(`Performing health check on ${url}`)
+
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+    const checkHealth = spawner.exitCode(ChildProcess.make('curl', ['-f', '-s', url])).pipe(
+      Effect.map((code: number) => code === 0),
+      Effect.orElseSucceed(() => false),
+    )
+
+    const healthCheck = checkHealth.pipe(
+      Effect.repeat({
+        while: (healthy: boolean) => healthy === false,
+        schedule: Schedule.fixed(interval),
+      }),
+      Effect.timeout(timeout),
+      Effect.mapError(
+        () =>
+          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: Options & {
+    healthCheck?: StartOptions['healthCheck']
+  },
+): Effect.Effect<
+  void,
+  DockerComposeError | PlatformError.PlatformError,
+  DockerCompose | ChildProcessSpawner.ChildProcessSpawner | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const dockerCompose = yield* DockerCompose
+
+    // Start the services
+    yield* dockerCompose.start({
+      ...omitUndefineds({ healthCheck: args.healthCheck !== undefined ? args.healthCheck : undefined }),
+    })
+
+    // Add cleanup finalizer to the current scope
+    yield* Effect.addFinalizer(() => dockerCompose.stop.pipe(Effect.orDie))
+  })

package/src/node/DockerCompose/mod.ts

@@ -0,0 +1 @@
+export * as DockerCompose from './DockerCompose.ts'

package/src/node/FileLogger.ts

@@ -1,48 +1,8 @@
-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),
-        }),
-      )
-    }),
-  )
+import { Redactable } from 'effect'
+
+import { Cause, Inspectable, Logger, type LogLevel, References, ReadonlyArray } from '@livestore/utils/effect'
 
 const withColor = (text: string, ...colors: ReadonlyArray<string>) => {
   let out = ''
@@ -66,18 +26,18 @@ const colors = {
   bgBrightRed: '101',
 } as const
 
-const logLevelColors: Record<LogLevel.LogLevel['_tag'], ReadonlyArray<string>> = {
+const logLevelColors: Record<LogLevel.LogLevel, ReadonlyArray<string>> = {
   None: [],
   All: [],
   Trace: [colors.gray],
   Debug: [colors.blue],
   Info: [colors.green],
-  Warning: [colors.yellow],
+  Warn: [colors.yellow],
   Error: [colors.red],
   Fatal: [colors.bgBrightRed, colors.black],
 }
 
-export const defaultDateFormat = (date: Date): string =>
+export const formatLogTime = (date: Date): string =>
   `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date
     .getSeconds()
     .toString()
@@ -91,7 +51,7 @@ export const structuredMessage = (u: unknown): unknown => {
       return String(u)
     }
     default: {
-      return Inspectable.toJSON(u)
+      return Inspectable.toJson(u)
     }
   }
 }
@@ -115,93 +75,108 @@ const consoleLogToString = (...s: any[]) => {
     .join(' ')
 }
 
-export const prettyLoggerTty = (options: {
+type PrettyLoggerOptions = {
   readonly colors: boolean
   readonly stderr: boolean
   readonly formatDate: (date: Date) => string
   readonly onLog?: (str: string) => void
+}
+
+export const formatPrettyLog = ({
+  annotations,
+  cause,
+  date,
+  fiberId,
+  logLevel,
+  message: message_,
+  options,
+  spans,
+}: {
+  readonly annotations: Readonly<Record<string, unknown>>
+  readonly cause: Cause.Cause<unknown>
+  readonly date: Date
+  readonly fiberId: number
+  readonly logLevel: LogLevel.LogLevel
+  readonly message: unknown
+  readonly options: PrettyLoggerOptions
+  readonly spans: ReadonlyArray<readonly [label: string, timestamp: number]>
 }) => {
   const color = options.colors === true ? withColor : withColorNoop
-  return Logger.make<unknown, string>(({ annotations, cause, date, fiberId, logLevel, message: message_, spans }) => {
-    let str = ''
+  let str = ''
 
-    const log = (...s: any[]) => {
-      str += `${consoleLogToString(...s)}\n`
-      options.onLog?.(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 logIndented = (...s: any[]) => {
+    str += `${consoleLogToString(...s).replace(/^/gm, '  ')}\n`
+    options.onLog?.(str)
+  }
 
-    const message = ReadonlyArray.ensure(message_)
+  const message = ReadonlyArray.ensure(message_)
 
-    let firstLine =
-      color(`[${options.formatDate(date)}]`, colors.white) +
-      ` ${color(logLevel.label, ...logLevelColors[logLevel._tag])}` +
-      ` (${FiberId.threadName(fiberId)})`
+  let firstLine =
+    color(`[${options.formatDate(date)}]`, colors.white) +
+    ` ${color(logLevel.toUpperCase(), ...logLevelColors[logLevel])}` +
+    ` (#${fiberId})`
 
-    if (List.isCons(spans) === true) {
-      const now = date.getTime()
-      const render = LogSpan.render(now)
-      for (const span of spans) {
-        firstLine += ` ${render(span)}`
-      }
+  if (spans.length > 0) {
+    const now = date.getTime()
+    for (const [label, timestamp] of spans) {
+      firstLine += ` ${label}=${now - timestamp}ms`
     }
+  }
 
-    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++
-      }
+  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()
+  log(firstLine)
+  // if (!processIsBun) console.group()
 
-    if (Cause.isEmpty(cause) === false) {
-      logIndented(Cause.pretty(cause, { renderErrorCause: true }))
-    }
+  if (cause.reasons.length > 0) {
+    logIndented(Cause.pretty(cause))
+  }
 
-    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 (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(Redactable.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)
-      }
-    }
+  for (const [key, value] of Object.entries(annotations)) {
+    const formattedValue =
+      typeof value === 'object' && value !== null
+        ? util.inspect(structuredMessage(value), {
+            depth: 3,
+            colors: false,
+            compact: false,
+            breakLength: 120,
+          })
+        : Redactable.redact(value)
+    logIndented(color(`${key}:`, colors.bold, colors.white), formattedValue)
+  }
 
-    // if (!processIsBun) console.groupEnd()
+  // if (!processIsBun) console.groupEnd()
 
-    return str
-  })
+  return str
 }

package/src/node/cmd-log.ts

@@ -1,8 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 
-import { isNotUndefined } from '@livestore/utils'
-import { Effect } from '@livestore/utils/effect'
+import { Cause, Effect, Predicate } from '@livestore/utils/effect'
 
 export type TCmdLoggingOptions = {
   readonly logDir?: string
@@ -31,18 +30,27 @@ export const prepareCmdLogging: (options: TCmdLoggingOptions) => Effect.Effect<s
     const safeIso = new Date().toISOString().replaceAll(':', '-')
     const archivedBase = `${path.parse(logFileName).name}-${safeIso}.log`
     const archivedLog = path.join(archiveDir, archivedBase)
-    yield* Effect.try(() => fs.renameSync(currentLogPath, archivedLog)).pipe(
-      Effect.catchAll(() =>
-        Effect.try(() => {
-          fs.copyFileSync(currentLogPath, archivedLog)
-          fs.truncateSync(currentLogPath, 0)
+    yield* Effect.try({
+      try: () => fs.renameSync(currentLogPath, archivedLog),
+      catch: (cause) => new Cause.UnknownError(cause),
+    }).pipe(
+      Effect.catch(() =>
+        Effect.try({
+          try: () => {
+            fs.copyFileSync(currentLogPath, archivedLog)
+            fs.truncateSync(currentLogPath, 0)
+          },
+          catch: (cause) => new Cause.UnknownError(cause),
         }),
       ),
       Effect.ignore,
     )
 
     // Prune archives to retain only the newest N
-    yield* Effect.try(() => fs.readdirSync(archiveDir)).pipe(
+    yield* Effect.try({
+      try: () => fs.readdirSync(archiveDir),
+      catch: (cause) => new Cause.UnknownError(cause),
+    }).pipe(
       Effect.map((names) => names.filter((n) => n.endsWith('.log'))),
       Effect.map((names) =>
         names
@@ -51,7 +59,10 @@ export const prepareCmdLogging: (options: TCmdLoggingOptions) => Effect.Effect<s
       ),
       Effect.flatMap((entries) =>
         Effect.forEach(entries.slice(logRetention), (e) =>
-          Effect.try(() => fs.unlinkSync(path.join(archiveDir, e.name))).pipe(Effect.ignore),
+          Effect.try({
+            try: () => fs.unlinkSync(path.join(archiveDir, e.name)),
+            catch: (cause) => new Cause.UnknownError(cause),
+          }).pipe(Effect.ignore),
         ),
       ),
       Effect.ignore,
@@ -71,7 +82,7 @@ export const applyLoggingToCommand: (
 ) => Effect.Effect<{ input: string | string[]; subshell: boolean; logPath?: string }> = Effect.fn('cmd.logging.apply')(
   function* (commandInput, options) {
     const asArray = Array.isArray(commandInput)
-    const parts = asArray === true ? commandInput.filter(isNotUndefined) : undefined
+    const parts = asArray === true ? commandInput.filter(Predicate.isNotUndefined) : undefined
 
     const logPath = yield* prepareCmdLogging(options)