@stacksjs/logging 0.63.0 → 0.64.0

package/src/index.ts

@@ -1,134 +1,126 @@
 import { access, appendFile, mkdir } from 'node:fs/promises'
 import { dirname } from 'node:path'
 import process from 'node:process'
-import type { Prompt } from '@stacksjs/cli'
-import { buddyOptions, prompt as getPrompt } from '@stacksjs/cli'
+import { prompts } from '@stacksjs/cli'
+import { config } from '@stacksjs/config'
 import { handleError } from '@stacksjs/error-handling'
-import { logsPath } from '@stacksjs/path'
 import { ExitCode } from '@stacksjs/types'
 import { isString } from '@stacksjs/validation'
-import { consola, createConsola } from 'consola'
-
-export async function logLevel() {
-  /**
-   * This regex checks for:
-   *   - --verbose true or --verbose=true exactly at the end of the string ($ denotes the end of the string).
-   *   - --verbose - followed by optional spaces at the end.
-   *   - --verbose followed by optional spaces at the end.
-   *
-   * .trim() is used on options to ensure any trailing spaces in the entire options string do not affect the regex match.
-   */
-  const verboseRegex = /--verbose(?!(\s*=\s*false|\s+false))(\s+|=true)?($|\s)/
-  const opts = buddyOptions()
-
-  if (verboseRegex.test(opts)) return 4
-
-  // const config = await import('@stacksjs/config')
-  // console.log('config', config)
-
-  return 3
-  // return config.logger.level
-}
-
-export const logger = createConsola({
-  level: await logLevel(),
-  // fancy: true,
-  // formatOptions: {
-  //     columns: 80,
-  //     colors: false,
-  //     compact: false,
-  //     date: false,
-  // },
-})
-
-export { consola }
+import isUnicodeSupported from 'is-unicode-supported'
+import color from 'picocolors'
 
 export async function writeToLogFile(message: string) {
   const formattedMessage = `[${new Date().toISOString()}] ${message}\n`
 
   try {
-    const logFilePath = logsPath('console.log')
+    const logFile = config.logging.logsPath ?? 'storage/logs/stacks.log'
 
     try {
       // Check if the file exists
-      await access(logFilePath)
+      await access(logFile)
     } catch {
       // File doesn't exist, create the directory
-      await mkdir(dirname(logFilePath), { recursive: true })
+      console.log('Creating log file directory...', logFile)
+      await mkdir(dirname(logFile), { recursive: true })
     }
 
     // Append the message to the log file
-    await appendFile(logFilePath, formattedMessage)
+    await appendFile(logFile, formattedMessage)
   } catch (error) {
     console.error('Failed to write to log file:', error)
   }
 }
 
 export interface Log {
-  info: (...args: any[]) => void
-  success: (msg: string) => void
+  info: (message: string, options?: LogMessageOptions) => void
+  success: (message: string, options?: LogMessageOptions) => void
   error: (err: string | Error | unknown, options?: any | Error) => void
-  warn: (arg: string) => void
-  debug: (...args: any[]) => void
-  // start: logger.Start
-  // box: logger.Box
-  start: any
-  box: any
-  prompt: Prompt
+  warn: (message: string, options?: LogMessageOptions) => void
+  warning: (message: string, options?: LogMessageOptions) => void
+  debug: (message: string, options?: LogMessageOptions) => void
+  message: (message: string, options?: LogMessageOptions) => void
+  step: (message: string, options?: LogMessageOptions) => void
   dump: (...args: any[]) => void
   dd: (...args: any[]) => void
   echo: (...args: any[]) => void
 }
 
+const unicode = isUnicodeSupported()
+const s = (c: string, fallback: string) => (unicode ? c : fallback)
+const S_INFO = s('●', '•')
+const S_SUCCESS = s('◆', '*')
+const S_WARN = s('▲', '!')
+const S_ERROR = s('■', 'x')
+const S_BAR = s('│', '|')
+const S_STEP_SUBMIT = s('◇', 'o')
+
+export type LogMessageOptions = {
+  symbol?: string
+  styled?: boolean
+}
+
 export const log: Log = {
-  async info(...arg: any) {
-    // @ts-expect-error intentional
-    logger.info(...arg)
-    await writeToLogFile(`INFO: ${arg}`)
-  },
+  message: (message = '', { symbol = color.gray(S_BAR), styled = true }: LogMessageOptions = {}) => {
+    if (!styled) return process.stdout.write(`${message}\n`)
 
-  async success(msg: string) {
-    logger.success(msg)
-    await writeToLogFile(`SUCCESS: ${msg}`)
-  },
+    const parts = [`${color.gray(S_BAR)}`]
 
-  async error(err: unknown, options?: any | Error) {
-    if (err instanceof Error) handleError(err, options)
-    else if (options instanceof Error) handleError(options)
-    else handleError(err, options)
+    if (message) {
+      const [firstLine, ...lines] = message.split('\n')
+      parts.push(`${symbol}  ${firstLine}`, ...lines.map((ln) => `${color.gray(S_BAR)}  ${ln}`))
+    }
 
-    await writeToLogFile(`ERROR: ${err}`)
+    process.stdout.write(`${parts.join('\n')}\n`)
   },
 
-  async warn(arg: string) {
-    logger.warn(arg)
-    await writeToLogFile(`WARN: ${arg}`)
+  info: async (message: string, options?: LogMessageOptions) => {
+    log.message(message, { symbol: color.blue(S_INFO), ...options })
+    await writeToLogFile(`INFO: ${message}`)
   },
 
-  async debug(...arg: any) {
-    if (process.env.APP_ENV === 'production' || process.env.APP_ENV === 'prod')
-      return await writeToLogFile(`DEBUG: ${arg}`)
+  success: async (message: string, options?: LogMessageOptions) => {
+    log.message(message, { symbol: color.green(S_SUCCESS), ...options })
+    await writeToLogFile(`SUCCESS: ${message}`)
+  },
 
-    logger.debug(arg)
+  step: async (message: string, options?: LogMessageOptions) => {
+    log.message(message, { symbol: color.green(S_STEP_SUBMIT), ...options })
+    await writeToLogFile(`STEP: ${message}`)
+  },
+
+  warn: async (message: string, options?: LogMessageOptions) => {
+    log.message(message, { symbol: color.yellow(S_WARN), ...options })
+    await writeToLogFile(`WARN: ${message}`)
+  },
 
-    if (isString(arg)) await writeToLogFile(`DEBUG: ${arg}`)
-    else await writeToLogFile(`DEBUG: ${JSON.stringify(arg)}`)
+  /** alias for `log.warn()`. */
+  warning: (message: string, options?: LogMessageOptions) => {
+    log.warn(message, options)
   },
 
-  async start(...arg: any) {
-    logger.start(arg)
-    await writeToLogFile(`START: ${arg}`)
+  error: (err: unknown, options?: any | Error) => {
+    if (err instanceof Error) handleError(err, options)
+    else if (err instanceof Error) handleError(options)
+    else handleError(err, options)
+
+    const errorMessage = isString(err) ? err : err instanceof Error ? err.message : String(err)
+    log.message(errorMessage, { symbol: color.red(S_ERROR) })
+    writeToLogFile(`ERROR: ${errorMessage}`)
   },
 
-  box: logger.box,
+  debug: (...args: any[]) => {
+    if (process.env.APP_ENV === 'production' || process.env.APP_ENV === 'prod')
+      return writeToLogFile(`DEBUG: ${args.join(' ')}`)
 
-  get prompt() {
-    return getPrompt()
+    writeToLogFile(`DEBUG: ${args.join(' ')}`)
   },
 
-  dump,
-  dd,
-  echo,
+  dump: (...args: any[]) => args.forEach((arg) => console.log(arg)),
+  dd: (...args: any[]) => {
+    args.forEach((arg) => console.log(arg))
+    process.exit(ExitCode.FatalError)
+  },
+  echo: (...args: any[]) => console.log(...args),
 }
 
 export function dump(...args: any[]) {