@livestore/utils-dev 0.0.0-snapshot-e5a7caabcf7660aefa55568a44ed0fe306d00597 → 0.0.0-snapshot-9d8807d2c51c95b4df3556744702cea55dc7ded3

package/src/node/DockerComposeService/DockerComposeService.ts

@@ -1,328 +0,0 @@
-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

@@ -1,4 +0,0 @@
-services:
-  hello-world:
-    image: hello-world
-    profiles: [manual] # Don't auto-start this service

package/src/node/FileLogger.ts

@@ -1,206 +0,0 @@
-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
-  })
-}

package/src/node/cmd-log.ts

@@ -1,92 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { isNotUndefined } from '@livestore/utils'
-import { Effect, identity } from '@livestore/utils/effect'
-
-export type TCmdLoggingOptions = {
-  readonly logDir?: string
-  readonly logFileName?: string
-  readonly logRetention?: number
-}
-
-/**
- * Prepares logging directories, archives previous canonical log and prunes archives.
- * Returns the canonical current log path if logging is enabled, otherwise undefined.
- */
-export const prepareCmdLogging: (options: TCmdLoggingOptions) => Effect.Effect<string | undefined, never, never> =
-  Effect.fn('cmd.logging.prepare')(function* ({
-    logDir,
-    logFileName = 'dev.log',
-    logRetention = 50,
-  }: TCmdLoggingOptions) {
-    if (!logDir || logDir === '') return undefined as string | undefined
-
-    const logsDir = logDir
-    const archiveDir = path.join(logsDir, 'archive')
-    const currentLogPath = path.join(logsDir, logFileName)
-
-    // Ensure directories exist
-    yield* Effect.sync(() => fs.mkdirSync(archiveDir, { recursive: true }))
-
-    // Archive previous log if present
-    if (fs.existsSync(currentLogPath)) {
-      const safeIso = new Date().toISOString().replaceAll(':', '-')
-      const archivedBase = `${path.parse(logFileName).name}-${safeIso}.log`
-      const archivedLog = path.join(archiveDir, archivedBase)
-      yield* Effect.try({ try: () => fs.renameSync(currentLogPath, archivedLog), catch: identity }).pipe(
-        Effect.catchAll(() =>
-          Effect.try({
-            try: () => {
-              fs.copyFileSync(currentLogPath, archivedLog)
-              fs.truncateSync(currentLogPath, 0)
-            },
-            catch: identity,
-          }),
-        ),
-        Effect.ignore,
-      )
-
-      // Prune archives to retain only the newest N
-      yield* Effect.try({ try: () => fs.readdirSync(archiveDir), catch: identity }).pipe(
-        Effect.map((names) => names.filter((n) => n.endsWith('.log'))),
-        Effect.map((names) =>
-          names
-            .map((name) => ({ name, mtimeMs: fs.statSync(path.join(archiveDir, name)).mtimeMs }))
-            .sort((a, b) => b.mtimeMs - a.mtimeMs),
-        ),
-        Effect.flatMap((entries) =>
-          Effect.forEach(entries.slice(logRetention), (e) =>
-            Effect.try({ try: () => fs.unlinkSync(path.join(archiveDir, e.name)), catch: identity }).pipe(
-              Effect.ignore,
-            ),
-          ),
-        ),
-        Effect.ignore,
-      )
-    }
-
-    return currentLogPath
-  })
-
-/**
- * Given a command input, applies logging by piping output through `tee` to the
- * canonical log file. Returns the transformed input and whether a shell is required.
- */
-export const applyLoggingToCommand: (
-  commandInput: string | (string | undefined)[],
-  options: TCmdLoggingOptions,
-) => Effect.Effect<{ input: string | string[]; subshell: boolean; logPath?: string }, never, never> = Effect.fn(
-  'cmd.logging.apply',
-)(function* (commandInput, options) {
-  const asArray = Array.isArray(commandInput)
-  const parts = asArray ? (commandInput as (string | undefined)[]).filter(isNotUndefined) : undefined
-
-  const logPath = yield* prepareCmdLogging(options)
-
-  return {
-    input: asArray ? ((parts as string[]) ?? []) : (commandInput as string),
-    subshell: false,
-    ...(logPath ? { logPath } : {}),
-  }
-})