chore: wip

chore: wip

chore: wip

chore: wip

Author: chrisbbreuer

resources/preloader/test.ts

@@ -1,9 +1,9 @@
-import { enableBrowserFeatures } from '@stacksjs/testing'
+import { setupTestEnvironment } from '@stacksjs/testing'
 
 /**
  * A place to register logic that should run before the tests run.
  * e.g. you may abstract your module mocks here, if you want
  * to prevent the original module from being evaluated.
  */
 
-enableBrowserFeatures()
+setupTestEnvironment()

storage/framework/core/error-handling/src/handler.ts

@@ -7,21 +7,24 @@ interface ErrorOptions {
   silent?: boolean
 }
 
-export const StacksError = Error
+type ErrorMessage = string
 
 export class ErrorHandler {
-  // static logFile = path.logsPath('errors.log')
-
-  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)
-
-    if (typeof err === 'string') err = new StacksError(err)
-    if (typeof err === 'object') err = err as Error
+  static handle(err: Error | ErrorMessage | unknown, options?: ErrorOptions): Error {
+    if (options?.silent !== true) this.writeErrorToConsole(err)
+
+    let error: Error
+    if (err instanceof Error) {
+      error = err
+    } else if (typeof err === 'string') {
+      error = new Error(err)
+    } else {
+      error = new Error(JSON.stringify(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 {
@@ -39,9 +42,7 @@ 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) {
       console.error('Failed to write to error file:', error)
@@ -53,13 +54,10 @@ export class ErrorHandler {
       err === `Failed to execute command: ${italic('bunx --bun biome check --fix')}` ||
       err === `Failed to execute command: ${italic('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
+      process.exit(ExitCode.FatalError)
     }
 
-    // when "undeploying," there currently is a chance that edge functions can't be destroyed yet, because of their distributed nature
-    // this is a temporary fix until AWS improves this on their side
     if (
       typeof err === 'string' &&
       err.includes('Failed to execute command:') &&
@@ -70,15 +68,13 @@ export class ErrorHandler {
         '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.',
       )
       console.log('Hoping to see you back soon!')
-      process.exit(ExitCode.FatalError) // TODO: abstract this by differently catching the error somewhere
+      process.exit(ExitCode.FatalError)
     }
 
     console.error(err)
   }
 }
 
-type ErrorDescription = string
-
-export function handleError(err: ErrorDescription | Error | unknown, options?: ErrorOptions): Error {
+export function handleError(err: ErrorMessage | Error | unknown, options?: ErrorOptions): Error {
   return ErrorHandler.handle(err, options)
 }

storage/framework/core/error-handling/src/utils.ts

@@ -1,7 +1,25 @@
-export function rescue<T>(fn: () => T, fallback: T): T {
+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 {
-    return fn()
-  } catch {
+    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
   }
 }

storage/framework/core/error-handling/tests/error-handling.test.ts

@@ -1,11 +1,30 @@
-import { describe, expect, it, mock } from 'bun:test'
+import { afterAll, beforeAll, describe, expect, it, mock, spyOn } from 'bun:test'
 import { italic } from '@stacksjs/cli'
+import * as path from '@stacksjs/path'
 import { ExitCode } from '@stacksjs/types'
+import fs from 'fs-extra'
 import { ErrorHandler, handleError } from '../src/handler'
 import { rescue } from '../src/utils'
 
-// Tests for ErrorHandler class
 describe('@stacksjs/error-handling', () => {
+  let originalConsoleError: typeof console.error
+  let originalProcessExit: typeof process.exit
+
+  beforeAll(() => {
+    originalConsoleError = console.error
+    console.error = () => {} // No-op function
+
+    originalProcessExit = process.exit
+    process.exit = () => {
+      throw new Error('process.exit() was called')
+    }
+  })
+
+  afterAll(() => {
+    console.error = originalConsoleError
+    process.exit = originalProcessExit
+  })
+
   describe('ErrorHandler', () => {
     it('should handle string errors', () => {
       const error = 'Test error'
@@ -20,66 +39,151 @@ describe('@stacksjs/error-handling', () => {
       expect(handledError).toBe(error)
     })
 
+    it('should handle non-Error objects', () => {
+      const nonError = { message: 'Not an Error' }
+      const handledError = ErrorHandler.handle(nonError)
+      expect(handledError).toBeInstanceOf(Error)
+      expect(handledError.message).toBe(JSON.stringify(nonError))
+    })
+
     it('should write error to console when not silent', () => {
-      const consoleErrorMock = mock(console, 'error')
+      const writeErrorToConsoleSpy = spyOn(ErrorHandler, 'writeErrorToConsole')
       const error = new Error('Test error')
       ErrorHandler.handle(error, { silent: false })
-      expect(consoleErrorMock).toHaveBeenCalledWith(error)
-      consoleErrorMock.mockRestore(redisTest)
+      expect(writeErrorToConsoleSpy).toHaveBeenCalledWith(error)
+      writeErrorToConsoleSpy.mockRestore()
+    })
+
+    it('should not write error to console when silent', () => {
+      const writeErrorToConsoleSpy = spyOn(ErrorHandler, 'writeErrorToConsole')
+      const error = new Error('Test error')
+      ErrorHandler.handle(error, { silent: true })
+      expect(writeErrorToConsoleSpy).not.toHaveBeenCalled()
+      writeErrorToConsoleSpy.mockRestore()
     })
 
     it('should write error to file', async () => {
+      const writeErrorToFileSpy = spyOn(ErrorHandler, 'writeErrorToFile')
       const error = new Error('Test error')
-      await ErrorHandler.writeErrorToFile(error)
-      // You can add more checks here to verify the file writing logic
+      await ErrorHandler.handle(error)
+      expect(writeErrorToFileSpy).toHaveBeenCalledWith(error)
+      writeErrorToFileSpy.mockRestore()
     })
 
     it('should handle specific command errors', () => {
-      const consoleErrorMock = mock(console, 'error')
-      const processExitMock = mock(process, 'exit')
+      const consoleErrorSpy = spyOn(console, 'error')
+      const processExitSpy = spyOn(process, 'exit')
 
       const error = `Failed to execute command: ${italic('bunx --bun biome check --fix')}`
-      ErrorHandler.writeErrorToConsole(error)
-      expect(consoleErrorMock).toHaveBeenCalledWith(error)
-      expect(processExitMock).toHaveBeenCalledWith(ExitCode.FatalError)
+      expect(() => ErrorHandler.writeErrorToConsole(error)).toThrow('process.exit() was called')
+      expect(consoleErrorSpy).toHaveBeenCalledWith(error)
+      expect(processExitSpy).toHaveBeenCalledWith(ExitCode.FatalError)
 
-      consoleErrorMock.mockRestore()
-      processExitMock.mockRestore()
+      consoleErrorSpy.mockRestore()
+      processExitSpy.mockRestore()
     })
-  })
 
-  // Tests for utility functions
-  describe('Utils', () => {
-    it('should return the result of the function if no error occurs', () => {
-      const result = rescue(() => 42, 0)
-      expect(result).toBe(42)
+    it('should format error message correctly when writing to file', async () => {
+      const appendFileSpy = spyOn(fs, 'appendFile')
+      const error = new Error('Test error')
+      await ErrorHandler.writeErrorToFile(error)
+      expect(appendFileSpy).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringMatching(/^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] Error: Test error\n$/),
+      )
+      appendFileSpy.mockRestore()
     })
 
-    it('should return the fallback value if an error occurs', () => {
-      const result = rescue(() => {
-        throw new Error('Test error')
-      }, 0)
-      expect(result).toBe(0)
+    it('should handle CDK destroy command errors', () => {
+      const consoleErrorSpy = spyOn(console, 'error')
+      const consoleLogSpy = spyOn(console, 'log')
+      const processExitSpy = spyOn(process, 'exit')
+
+      const error = 'Failed to execute command: bunx --bun cdk destroy'
+      expect(() => ErrorHandler.writeErrorToConsole(error)).toThrow('process.exit() was called')
+      expect(consoleErrorSpy).toHaveBeenCalledWith(error)
+      expect(consoleLogSpy).toHaveBeenCalledTimes(2)
+      expect(processExitSpy).toHaveBeenCalledWith(ExitCode.FatalError)
+
+      consoleErrorSpy.mockRestore()
+      consoleLogSpy.mockRestore()
+      processExitSpy.mockRestore()
+    })
+
+    it('should use correct log file path', async () => {
+      const mkdirSpy = spyOn(fs, 'mkdir')
+      const appendFileSpy = spyOn(fs, 'appendFile')
+      const error = new Error('Test error')
+      await ErrorHandler.writeErrorToFile(error)
+      expect(mkdirSpy).toHaveBeenCalledWith(expect.any(String), expect.anything())
+      expect(appendFileSpy.mock.calls[0][0]).toMatch(/stacks\.log$/)
+      mkdirSpy.mockRestore()
+      appendFileSpy.mockRestore()
     })
   })
 
-  // Tests for handleError function
-  describe('handleError', () => {
-    it('should handle string errors', () => {
-      const error = 'Test error'
-      const handledError = handleError(error)
-      expect(handledError).toBeInstanceOf(Error)
-      expect(handledError.message).toBe(error)
+  describe('Utils', () => {
+    describe('handleError function', () => {
+      it('should handle string errors', () => {
+        const error = 'Test error'
+        const handledError = handleError(error)
+        expect(handledError).toBeInstanceOf(Error)
+        expect(handledError.message).toBe(error)
+      })
+
+      it('should handle Error objects', () => {
+        const error = new Error('Test error')
+        const handledError = handleError(error)
+        expect(handledError).toBe(error)
+      })
+
+      it('should handle unknown objects', () => {
+        const unknown = { foo: 'bar' }
+        const handledError = handleError(unknown)
+        expect(handledError).toBeInstanceOf(Error)
+        expect(handledError.message).toBe(JSON.stringify(unknown))
+      })
     })
 
-    it('should handle Error objects', () => {
-      const error = new Error('Test error')
-      const handledError = handleError(error)
-      expect(handledError).toBe(error)
+    describe('rescue function', () => {
+      it('should return the result of the function if no error occurs', () => {
+        const result = rescue(() => 42, 0)
+        expect(result).toBe(42)
+      })
+
+      it('should return the fallback value if an error occurs', () => {
+        const result = rescue(() => {
+          throw new Error('Test error')
+        }, 0)
+        expect(result).toBe(0)
+      })
+
+      it('should handle async functions', async () => {
+        const result = await rescue(async () => {
+          throw new Error('Async error')
+        }, 'fallback')
+        expect(result).toBe('fallback')
+      })
+
+      it('should pass error to onError callback if provided', () => {
+        const onErrorMock = mock(() => {})
+        rescue(
+          () => {
+            throw new Error('Test error')
+          },
+          0,
+          onErrorMock,
+        )
+        expect(onErrorMock).toHaveBeenCalledWith(expect.any(Error))
+      })
+
+      it('should handle successful async operations', async () => {
+        const result = await rescue(async () => 'async result', 'fallback')
+        expect(result).toBe('async result')
+      })
     })
   })
 
-  // Tests for index.ts exports
   describe('ErrorHandling Index', () => {
     it('should export ErrorHandler', () => {
       expect(ErrorHandler).toBeDefined()

storage/framework/core/testing/src/feature.ts

@@ -3,3 +3,9 @@ export { GlobalRegistrator } from '@happy-dom/global-registrator'
 export function enableBrowserFeatures() {
   return GlobalRegistrator.register()
 }
+
+export function setupTestEnvironment() {
+  process.env.NODE_ENV = 'test'
+  process.env.APP_ENV = 'test'
+  return GlobalRegistrator.register()
+}

storage/framework/core/types/src/errors.ts

@@ -7,7 +7,6 @@
 //   toString(): string
 // }
 
-// export type StacksError = Error
 export type CommandError = Error
 
 export interface ErrorOptions {