feat!: update onFinish state (#332)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **Refactor**
- Enhanced clarity in the management of operation outcomes, providing
more explicit error and success indications.
- **Tests**
- Modified test cases to align with the updated outcome handling,
ensuring accurate validation of results.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: dinwwwh

packages/shared/src/interceptor.test-d.ts

@@ -57,8 +57,15 @@ it('onError', () => {
 })
 
 it('onFinish', () => {
-  const interceptor: Interceptor<{ foo: string }, 'success', 'error'> = onFinish((state, options) => {
-    expectTypeOf(state).toEqualTypeOf<['success', null, 'success'] | [undefined, 'error', 'error']>()
+  const interceptor: Interceptor<{ foo: string }, 'success', 'error'> = onFinish(([error, data, isSuccess], options) => {
+    if (error || !isSuccess) {
+      expectTypeOf(error).toEqualTypeOf<'error'>()
+      expectTypeOf(data).toEqualTypeOf<undefined>()
+    }
+    else {
+      expectTypeOf(error).toEqualTypeOf<null>()
+      expectTypeOf(data).toEqualTypeOf<'success'>()
+    }
 
     expectTypeOf(options.foo).toEqualTypeOf<string>()
     expectTypeOf(options.next).toBeCallableWith<[options?: { foo: string }]>()
@@ -67,8 +74,16 @@ it('onFinish', () => {
 
   os.$context<{ something: string }>().use(onFinish(() => { }))
 
-  os.$context<{ something: string }>().use(onFinish((state, { context, next }) => {
-    expectTypeOf(state).toEqualTypeOf<[Awaited<MiddlewareResult<Context, unknown>>, null, 'success'] | [undefined, Error, 'error']>()
+  os.$context<{ something: string }>().use(onFinish(([error, data, isSuccess], { context, next }) => {
+    if (error || !isSuccess) {
+      expectTypeOf(error).toEqualTypeOf<Error>()
+      expectTypeOf(data).toEqualTypeOf<undefined>()
+    }
+    else {
+      expectTypeOf(error).toEqualTypeOf<null>()
+      expectTypeOf(data).toEqualTypeOf<Awaited<MiddlewareResult<Context, unknown>>>()
+    }
+
     expectTypeOf(context).toEqualTypeOf<{ something: string }>()
     expectTypeOf(next).toEqualTypeOf<MiddlewareNextFn<unknown>>()
   })).handler(({ context }) => {

packages/shared/src/interceptor.test.ts

@@ -156,7 +156,7 @@ describe('onStart / onSuccess / onError / onFinish', () => {
 
     expect(onFinishFn).toHaveBeenCalledTimes(1)
     expect(onFinishFn).toHaveBeenCalledWith(
-      ['__main__', null, 'success'],
+      [null, '__main__', true],
       {
         foo: 'bar',
         next: expect.any(Function),
@@ -197,7 +197,7 @@ describe('onStart / onSuccess / onError / onFinish', () => {
 
     expect(onFinishFn).toHaveBeenCalledTimes(1)
     expect(onFinishFn).toHaveBeenCalledWith(
-      [undefined, new Error('__error__'), 'error'],
+      [new Error('__error__'), undefined, false],
       {
         foo: 'bar',
         next: expect.any(Function),

packages/shared/src/interceptor.ts

@@ -63,7 +63,9 @@ export function onError<T, TOptions extends { next(): any }, TRest extends any[]
   }
 }
 
-export type OnFinishState<TResult, TError> = [TResult, null, 'success'] | [undefined, TError, 'error']
+export type OnFinishState<TResult, TError> =
+  | [error: TError, data: undefined, isSuccess: false]
+  | [error: null, data: TResult, isSuccess: true]
 
 /**
  * Can used for interceptors or middlewares
@@ -83,11 +85,11 @@ export function onFinish<T, TOptions extends { next(): any }, TRest extends any[
   return async (options, ...rest) => {
     try {
       const result = await options.next()
-      state = [result, null, 'success']
+      state = [null, result, true]
       return result
     }
     catch (error) {
-      state = [undefined, error, 'error']
+      state = [error, undefined, false]
       throw error
     }
     finally {