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

package/src/node/FileLogger.ts

@@ -1,47 +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 = ''
@@ -65,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()
@@ -90,7 +51,7 @@ export const structuredMessage = (u: unknown): unknown => {
       return String(u)
     }
     default: {
-      return Inspectable.toJSON(u)
+      return Inspectable.toJson(u)
     }
   }
 }
@@ -114,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 ? withColor : withColorNoop
-  return Logger.make<unknown, string>(({ annotations, cause, date, fiberId, logLevel, message: message_, spans }) => {
-    let str = ''
+  const color = options.colors === true ? withColor : withColorNoop
+  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)) {
-      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)) {
-      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

@@ -0,0 +1,95 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { Cause, Effect, Predicate } 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> = Effect.fn(
+  'cmd.logging.prepare',
+)(function* ({ logDir, logFileName = 'dev.log', logRetention = 50 }: TCmdLoggingOptions) {
+  if (logDir == null || 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) === true) {
+    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: (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({
+      try: () => fs.readdirSync(archiveDir),
+      catch: (cause) => new Cause.UnknownError(cause),
+    }).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: (cause) => new Cause.UnknownError(cause),
+          }).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 }> = Effect.fn('cmd.logging.apply')(
+  function* (commandInput, options) {
+    const asArray = Array.isArray(commandInput)
+    const parts = asArray === true ? commandInput.filter(Predicate.isNotUndefined) : undefined
+
+    const logPath = yield* prepareCmdLogging(options)
+
+    return {
+      input: asArray === true ? ((parts as string[]) ?? []) : commandInput,
+      subshell: false,
+      ...(logPath !== undefined ? { logPath } : {}),
+    }
+  },
+)

package/src/node/cmd.test.ts

@@ -0,0 +1,136 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { expect } from 'vitest'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { ChildProcessSpawner, Duration, Effect, Layer } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+
+import { cmd } from './cmd.ts'
+import { CurrentWorkingDirectory } from './workspace.ts'
+
+const withNode = Vitest.makeWithTestCtx({
+  makeLayer: () => Layer.mergeAll(PlatformNode.NodeServices.layer, CurrentWorkingDirectory.live),
+  timeout: 20_000,
+})
+
+Vitest.describe('cmd helper', () => {
+  const ansiRegex = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g')
+
+  Vitest.live('runs tokenized string without shell', (test) =>
+    Effect.gen(function* () {
+      const exit = yield* cmd('printf ok')
+      expect(exit).toBe(ChildProcessSpawner.ExitCode(0))
+    }).pipe(withNode(test)),
+  )
+
+  Vitest.live('runs array input', (test) =>
+    Effect.gen(function* () {
+      const exit = yield* cmd(['printf', 'ok'])
+      expect(exit).toBe(ChildProcessSpawner.ExitCode(0))
+    }).pipe(withNode(test)),
+  )
+
+  /** TODO(#1020): Investigate CI timeout flakiness for cmd tests that spawn many child processes */
+  Vitest.live(
+    'supports logging with archive + retention',
+    (test) =>
+      Effect.gen(function* () {
+        const workspace = process.env.WORKSPACE_ROOT!
+        const logsDir = path.join(workspace, 'tmp', 'cmd-tests', String(Date.now()))
+
+        // first run
+        const exit1 = yield* cmd('printf first', { logDir: logsDir })
+        expect(exit1).toBe(ChildProcessSpawner.ExitCode(0))
+        const current = path.join(logsDir, 'dev.log')
+        expect(fs.existsSync(current)).toBe(true)
+        const firstLog = fs.readFileSync(current, 'utf8')
+        const firstStdoutLines = firstLog.split('\n').filter((line) => line.includes('[stdout]'))
+        expect(firstStdoutLines.length).toBeGreaterThan(0)
+        for (const line of firstStdoutLines) {
+          expect(line).toContain('[stdout] first')
+          expect(line).toMatch(/Info/i)
+          expect(line).toContain('printf first')
+        }
+
+        // second run — archives previous
+        const exit2 = yield* cmd('printf second', { logDir: logsDir })
+        expect(exit2).toBe(ChildProcessSpawner.ExitCode(0))
+        const archiveDir = path.join(logsDir, 'archive')
+        const archives = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
+        expect(archives.length).toBe(1)
+        const archivedPath = path.join(archiveDir, archives[0]!)
+        const archivedLog = fs.readFileSync(archivedPath, 'utf8')
+        const archivedStdoutLines = archivedLog.split('\n').filter((line) => line.includes('[stdout]'))
+        expect(archivedStdoutLines.length).toBeGreaterThan(0)
+        for (const line of archivedStdoutLines) {
+          expect(line).toContain('[stdout] first')
+        }
+
+        const secondLog = fs.readFileSync(current, 'utf8')
+        const secondStdoutLines = secondLog.split('\n').filter((line) => line.includes('[stdout]'))
+        expect(secondStdoutLines.length).toBeGreaterThan(0)
+        for (const line of secondStdoutLines) {
+          expect(line).toContain('[stdout] second')
+          expect(line).toMatch(/Info/i)
+        }
+
+        // generate many archives to exercise retention (keep 50)
+        for (let i = 0; i < 60; i++) {
+          // Use small unique payloads
+          yield* cmd(['printf', String(i)], { logDir: logsDir })
+        }
+        const archivesAfter = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
+        expect(archivesAfter.length).toBeLessThanOrEqual(50)
+      }).pipe(withNode(test)),
+    { timeout: 30_000, retry: 3 },
+  )
+
+  Vitest.live('streams stdout and stderr with logger formatting', (test) =>
+    Effect.gen(function* () {
+      const workspace = process.env.WORKSPACE_ROOT!
+      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', `format-${Date.now()}`)
+
+      const exit = yield* cmd(['node', '-e', "console.log('out'); console.error('err')"], {
+        logDir: logsDir,
+      })
+      expect(exit).toBe(ChildProcessSpawner.ExitCode(0))
+
+      const current = path.join(logsDir, 'dev.log')
+      const logContent = fs.readFileSync(current, 'utf8')
+      expect(logContent).toMatch(/\[stdout] out/)
+      expect(logContent).toMatch(/\[stderr] err/)
+
+      const relevantLines = logContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.includes('[stdout]') || line.includes('[stderr]'))
+
+      expect(relevantLines.length).toBeGreaterThanOrEqual(2)
+
+      for (const line of relevantLines) {
+        const stripped = line.replace(ansiRegex, '')
+        expect(stripped.startsWith('[')).toBe(true)
+        expect(stripped).toMatch(/(Info|Warn)/i)
+        expect(stripped).toMatch(/\[(stdout|stderr)]/)
+      }
+    }).pipe(withNode(test)),
+  )
+
+  Vitest.live('cleans up logged child process when interrupted', (test) =>
+    Effect.gen(function* () {
+      const workspace = process.env.WORKSPACE_ROOT!
+      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', `timeout-${Date.now()}`)
+
+      const result = yield* cmd(['node', '-e', 'setTimeout(() => {}, 5000)'], {
+        logDir: logsDir,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      }).pipe(Effect.timeoutOption(Duration.millis(200)))
+
+      expect(result._tag).toBe('None')
+      expect(fs.existsSync(path.join(logsDir, 'dev.log'))).toBe(true)
+    }).pipe(withNode(test)),
+  )
+})