@stacksjs/error-handling 0.64.5 → 0.65.0

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function rescue<
+	T,
+	F
+>(fn: () => T | Promise<T>, fallback: F, onError?: (error: Error) => void): T | F | Promise<T | F>;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/error-handling",
   "type": "module",
-  "version": "0.64.5",
+  "version": "0.65.0",
   "description": "Type safe error handling.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/error-handling#readme",
@@ -15,13 +16,7 @@
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
   },
-  "keywords": [
-    "errors",
-    "error-handling",
-    "neverthrow",
-    "type safe",
-    "stacks"
-  ],
+  "keywords": ["errors", "error-handling", "neverthrow", "type safe", "stacks"],
   "exports": {
     ".": {
       "bun": "./src/index.ts",
@@ -33,26 +28,19 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
-  "dependencies": {
-    "@stacksjs/cli": "latest",
-    "@stacksjs/path": "latest",
-    "@stacksjs/types": "latest",
-    "neverthrow": "^7.0.1"
-  },
   "devDependencies": {
-    "@stacksjs/development": "latest"
+    "@stacksjs/cli": "0.64.6",
+    "@stacksjs/config": "0.64.6",
+    "@stacksjs/development": "0.64.6",
+    "@stacksjs/path": "0.64.6",
+    "@stacksjs/types": "0.64.6",
+    "@stacksjs/validation": "0.64.6",
+    "neverthrow": "^8.0.0"
   }
 }

package/src/handler.ts

@@ -1,25 +1,51 @@
+import type { ErrorOptions } from '@stacksjs/logging'
+import { access, appendFile, mkdir } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import process from 'node:process'
+import { italic, stripAnsi } from '@stacksjs/cli'
+import { config } from '@stacksjs/config'
 import * as path from '@stacksjs/path'
 import { ExitCode } from '@stacksjs/types'
-import fs from 'fs-extra'
+import { isString } from '@stacksjs/validation'
 
-interface ErrorOptions {
-  silent?: boolean
-}
-
-export const StacksError = Error
+type ErrorMessage = string
 
 export class ErrorHandler {
-  // static logFile = path.logsPath('errors.log')
+  static isTestEnvironment = false
+  static shouldExitProcess = true
+
+  static handle(err: Error | ErrorMessage | unknown, options?: ErrorOptions): Error {
+    this.shouldExitProcess = options?.shouldExit !== false
+    if (options?.silent !== true)
+      this.writeErrorToConsole(err)
+
+    let errorMessage: string
+
+    if (options?.message) {
+      // Use the message from options if provided
+      errorMessage = options.message
+    }
+    else if (err instanceof Error) {
+      errorMessage = err.message
+    }
+    else if (typeof err === 'string') {
+      errorMessage = err
+    }
+    else {
+      errorMessage = JSON.stringify(err)
+    }
 
-  static handle(err: ErrorDescription | Error | unknown, options?: ErrorOptions): Error {
-    // let's only write to the console if we are not in silent mode
-    if (options?.silent !== false) this.writeErrorToConsole(err)
+    // Create a new Error with the determined message
+    const error = new Error(errorMessage)
 
-    if (typeof err === 'string') err = new StacksError(err)
+    // If the original err was an Error instance, copy its properties
+    if (err instanceof Error) {
+      Object.assign(error, err)
+    }
 
-    this.writeErrorToFile(err).catch((e) => console.error(e))
+    this.writeErrorToFile(error).catch(e => console.error(e))
 
-    return err as Error // TODO: improve this type
+    return error
   }
 
   static handleError(err: Error, options?: ErrorOptions): Error {
@@ -27,7 +53,7 @@ export class ErrorHandler {
     return err
   }
 
-  static async writeErrorToFile(err: Error | unknown) {
+  static async writeErrorToFile(err: Error | unknown): Promise<void> {
     if (!(err instanceof Error)) {
       console.error('Error is not an instance of Error:', err)
       return
@@ -37,29 +63,86 @@ export class ErrorHandler {
     const logFilePath = path.logsPath('stacks.log') ?? path.logsPath('errors.log')
 
     try {
-      // Ensure the directory exists
-      await fs.mkdir(path.dirname(logFilePath), { recursive: true })
-      // Append the message to the log file
-      await fs.appendFile(logFilePath, formattedError)
-    } catch (error) {
+      await mkdir(path.dirname(logFilePath), { recursive: true })
+      await appendFile(logFilePath, formattedError)
+    }
+    catch (error) {
       console.error('Failed to write to error file:', error)
     }
   }
 
   static writeErrorToConsole(err: string | Error | unknown): void {
-    if (
-      err === 'Failed to execute command: bunx biome check --fix' ||
-      err === 'Failed to execute command: bun --bun storage/framework/core/actions/src/lint/fix.ts'
-    )
-      // To trigger this, run `buddy release` with a lint error in your codebase
-      console.error(err)
-    process.exit(ExitCode.FatalError) // TODO: abstract this by differently catching the error somewhere
     console.error(err)
+
+    const errorString = typeof err === 'string' ? err : err instanceof Error ? err.message : JSON.stringify(err)
+
+    if (
+      errorString.includes('bunx --bun cdk destroy')
+      || errorString === `Failed to execute command: ${italic('bunx --bun eslint . --fix')}`
+      || errorString === `Failed to execute command: ${italic('bun storage/framework/core/actions/src/lint/fix.ts')}`
+    ) {
+      if (!this.isTestEnvironment) {
+        // eslint-disable-next-line no-console
+        console.log(
+          'No need to worry. The edge function is currently being destroyed. Please run `buddy undeploy` shortly again, and continue doing so until it succeeds running.',
+        )
+        // eslint-disable-next-line no-console
+        console.log('Hoping to see you back soon!')
+      }
+    }
+
+    if (this.shouldExitProcess) {
+      process.exit(ExitCode.FatalError)
+    }
   }
 }
 
-type ErrorDescription = string
+export function handleError(err: string | Error | object | unknown, options?: ErrorOptions): Error {
+  let errorMessage: string
+
+  if (isString(err)) {
+    errorMessage = err
+  }
+  else if (err instanceof Error) {
+    errorMessage = err.message
+  }
+  else if (options instanceof Error) {
+    errorMessage = options.message
+  }
+  else {
+    errorMessage = String(err)
+  }
+
+  writeToLogFile(`ERROR: ${stripAnsi(errorMessage)}`)
 
-export function handleError(err: ErrorDescription | Error | unknown, options?: ErrorOptions): Error {
   return ErrorHandler.handle(err, options)
 }
+
+interface WriteOptions {
+  logFile?: string
+}
+
+export async function writeToLogFile(message: string, options?: WriteOptions): Promise<void> {
+  const formattedMessage = `[${new Date().toISOString()}] ${message}\n`
+
+  try {
+    const logFile = options?.logFile ?? config.logging.logsPath ?? 'storage/logs/stacks.log'
+
+    try {
+      // Check if the file exists
+      await access(logFile)
+    }
+    catch {
+      // File doesn't exist, create the directory
+      // eslint-disable-next-line no-console
+      console.log('Creating log file directory...', logFile)
+      await mkdir(dirname(logFile), { recursive: true })
+    }
+
+    // Append the message to the log file
+    await appendFile(logFile, formattedMessage)
+  }
+  catch (error) {
+    console.error('Failed to write to log file:', error)
+  }
+}

package/src/index.ts

@@ -1,14 +1,15 @@
 export * from './handler'
+export * from './utils'
 export {
   err,
+  Err,
   errAsync,
   fromPromise,
   fromSafePromise,
   fromThrowable,
   ok,
-  okAsync,
-  Err,
   Ok,
+  okAsync,
   Result,
   ResultAsync,
 } from 'neverthrow'

package/src/utils.ts

@@ -0,0 +1,26 @@
+import { ErrorHandler } from './handler'
+
+export function rescue<T, F>(
+  fn: () => T | Promise<T>,
+  fallback: F,
+  onError?: (error: Error) => void,
+): T | F | Promise<T | F> {
+  try {
+    const result = fn()
+    if (result instanceof Promise) {
+      return result.catch((error) => {
+        if (onError) {
+          onError(ErrorHandler.handle(error))
+        }
+        return fallback
+      })
+    }
+    return result
+  }
+  catch (error) {
+    if (onError) {
+      onError(ErrorHandler.handle(error))
+    }
+    return fallback
+  }
+}