Merge pull request #21 from xzhavilla/fix/unknown-error

xzhayon · Apr 24, 2024 · 781340e · 781340e
2 parents 851b6f7 + 2598392
commit 781340e
Show file tree

Hide file tree

Showing 3 changed files with 112 additions and 27 deletions.
diff --git a/src/Error.test.ts b/src/Error.test.ts
@@ -1,4 +1,6 @@
+import * as $Cause from './Cause'
 import * as $Error from './Error'
+import * as $Exit from './Exit'
 import * as $Layer from './Layer'
 import { Result } from './Result'
 import * as $Runtime from './Runtime'
@@ -15,49 +17,54 @@ describe('Error', () => {
 
   const tag = $Tag.tag<Divide>()
   const divide = $Proxy.function(tag)
+  const layer = $Layer.layer().with(tag, function* (a, b) {
+    if (b === 0) {
+      yield* $Exception.raise(new Error('Cannot divide by zero'))
+    }
 
-  describe('tryCatch', () => {
-    const layer = $Layer.layer().with(tag, function* (a, b) {
-      if (b === 0) {
-        yield* $Exception.raise(new Error('Cannot divide by zero'))
-      }
-
-      return a / b
-    })
+    return a / b
+  })
 
-    test('forwarding error', async () => {
+  describe('tryCatch', () => {
+    test.failing('forwarding error', async () => {
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           $Error.tryCatch(divide(42, 0), function* (error) {
             throw error
           }),
           layer,
         ),
-      ).rejects.toThrow('Cannot divide by zero')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.die(new Error('Cannot divide by zero'))),
+      )
     })
 
     test('throwing new error', async () => {
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           $Error.tryCatch(divide(42, 0), function* () {
             throw new Error('Cannot recover from exception')
           }),
           layer,
         ),
-      ).rejects.toThrow('Cannot recover from exception')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.die(new Error('Cannot recover from exception'))),
+      )
     })
 
     test('raising new error', async () => {
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           $Error.tryCatch(divide(42, 0), function* () {
             return yield* $Exception.raise(
               new Error('Cannot recover from exception'),
             )
           }),
           layer,
         ),
-      ).rejects.toThrow('Cannot recover from exception')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new Error('Cannot recover from exception'))),
+      )
     })
 
     test('returning value', async () => {
@@ -89,5 +96,44 @@ describe('Error', () => {
         ),
       ).resolves.toStrictEqual(42)
     })
+
+    test('handling unexpected errors', async () => {
+      class FooError extends Error {
+        readonly [uri]!: 'Foo'
+      }
+
+      class BarError extends Error {
+        readonly [uri]!: 'Bar'
+      }
+
+      await expect(
+        $Runtime.runExit(function* () {
+          // @ts-expect-error
+          return (yield* $Error.tryCatch(
+            function* () {
+              if (false) {
+                return yield* $Exception.raise(new FooError())
+              }
+
+              throw new BarError()
+            },
+            function* (error) {
+              switch (error[uri]) {
+                case 'Foo':
+                  return 'foo'
+              }
+            },
+          )).length
+        }, $Layer.layer()),
+      ).resolves.toStrictEqual(
+        $Exit.failure(
+          $Cause.die(
+            new TypeError(
+              "Cannot read properties of undefined (reading 'length')",
+            ),
+          ),
+        ),
+      )
+    })
   })
 })
diff --git a/src/Error.ts b/src/Error.ts
@@ -5,6 +5,10 @@ export interface NullError {
   readonly [uri]?: unique symbol
 }
 
+export interface UnknownError {
+  readonly [uri]?: unique symbol
+}
+
 export function is(u: unknown): u is Error {
   return u instanceof Error
 }
@@ -15,7 +19,7 @@ export function isAggregate(error: Error): error is AggregateError {
 
 export function* tryCatch<A extends Generator, B extends Generator>(
   effector: OrLazy<A>,
-  onError: (error: $Generator.TOf<A>) => B,
+  onError: (error: $Generator.TOf<A> | UnknownError) => B,
 ): Generator<
   $Generator.YOf<A> | $Generator.YOf<B>,
   $Generator.ROf<A> | $Generator.ROf<B>,

diff --git a/src/effect/Exception.test.ts b/src/effect/Exception.test.ts
@@ -1,3 +1,5 @@
+import * as $Cause from '../Cause'
+import * as $Exit from '../Exit'
 import * as $Layer from '../Layer'
 import { Result } from '../Result'
 import * as $Runtime from '../Runtime'
@@ -26,7 +28,7 @@ describe('Exception', () => {
       const random = $Proxy.function(tagRandom)
 
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           random,
           // @ts-expect-error
           $Layer.layer().with(tagRandom, function* () {
@@ -35,12 +37,14 @@ describe('Exception', () => {
             )
           }),
         ),
-      ).rejects.toThrow('Cannot return random number')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new Error('Cannot return random number'))),
+      )
     })
 
     test('raising error', async () => {
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           divide(42, 0),
           $Layer.layer().with(tag, function* (a, b) {
             if (b === 0) {
@@ -50,14 +54,16 @@ describe('Exception', () => {
             return a / b
           }),
         ),
-      ).rejects.toThrow('Cannot divide by zero')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new Error('Cannot divide by zero'))),
+      )
     })
 
     test('raising error subclass', async () => {
       class FooError extends Error {}
 
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           divide(42, 0),
           $Layer.layer().with(tag, function* (a, b) {
             if (b === 0) {
@@ -67,16 +73,18 @@ describe('Exception', () => {
             return a / b
           }),
         ),
-      ).rejects.toThrow('Cannot divide by zero')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new FooError('Cannot divide by zero'))),
+      )
     })
 
     test('raising different error', async () => {
       class BarError extends Error {
-        readonly [uri]!: 'BarError'
+        readonly [uri]!: 'Bar'
       }
 
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           divide(42, 0),
           // @ts-expect-error
           $Layer.layer().with(tag, function* (a, b) {
@@ -87,7 +95,32 @@ describe('Exception', () => {
             return a / b
           }),
         ),
-      ).rejects.toThrow('Cannot divide by zero')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new BarError('Cannot divide by zero'))),
+      )
+    })
+
+    test('rethrowing error', async () => {
+      await expect(
+        $Runtime.runExit(
+          function* () {
+            try {
+              return yield* divide(42, 0)
+            } catch (error) {
+              throw error
+            }
+          },
+          $Layer.layer().with(tag, function* (a, b) {
+            if (b === 0) {
+              yield* $Exception.raise(new Error('Cannot divide by zero'))
+            }
+
+            return a / b
+          }),
+        ),
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new Error('Cannot divide by zero'))),
+      )
     })
 
     test('raising error and performing effect', async () => {
@@ -100,7 +133,7 @@ describe('Exception', () => {
       const random = $Proxy.function(tagRandom)
 
       await expect(
-        $Runtime.runPromise(
+        $Runtime.runExit(
           divide(42, 0),
           $Layer
             .layer()
@@ -113,7 +146,9 @@ describe('Exception', () => {
             })
             .with(tagRandom, () => Math.random()),
         ),
-      ).rejects.toThrow('Cannot divide by zero')
+      ).resolves.toStrictEqual(
+        $Exit.failure($Cause.fail(new Error('Cannot divide by zero'))),
+      )
     })
   })
 })