Merge pull request #83 from uniocjs/dev-groupguanfang

docs(changeset): feat: add custom error handler (#82)

Author: Groupguanfang

.changeset/little-donuts-act.md

@@ -0,0 +1,5 @@
+---
+"@unioc/core": patch
+---
+
+feat: add custom error handler (#82)

packages/core/core/src/bootstrap.ts

@@ -62,12 +62,12 @@ export abstract class AbstractBootstrap extends AbstractContext implements IBoot
   async initialize(): Promise<void> {
     if (this.isInitialized)
       return
-
     const logger = await this.getInternalLogger()
     const pluginContext = new PluginContext(this, logger)
     const pluginList = await this._pluginResolver.getResolvedPlugins()
     const pluginExecutor = new PluginExecutor(pluginList, pluginContext)
     super.setPluginExecutor(pluginExecutor)
+    pluginContext.setPluginExecutor(pluginExecutor)
     Service.CONTAINER.forEach(cls => super.createClass(cls))
     await pluginExecutor.executeInstall()
     this.isInitialized = true

packages/core/core/src/contexts/plugins/plugin-context.ts

@@ -1,4 +1,5 @@
-import type { IBootstrap, IContainer, IInternalLogger, IPluginContext } from '../../types'
+import type { IBootstrap, IContainer, IHandleExecutorOptions, IInternalLogger, IPlugin, IPluginContext } from '../../types'
+import type { PluginExecutor } from './plugin-executor'
 import k from 'kleur'
 import { GLOBAL_CONTAINER } from '../../container/container'
 import { AbstractContext } from '../context'
@@ -9,6 +10,10 @@ export class PluginContext extends AbstractContext implements IPluginContext {
     private readonly _logger: IInternalLogger,
   ) { super() }
 
+  setPluginExecutor(pluginExecutor: PluginExecutor): this {
+    return super.setPluginExecutor(pluginExecutor)
+  }
+
   getGlobalContainer(): IContainer {
     return GLOBAL_CONTAINER
   }
@@ -37,4 +42,18 @@ export class PluginContext extends AbstractContext implements IPluginContext {
     this._pluginName = pluginName
     return this
   }
+
+  async handle(options: IHandleExecutorOptions): Promise<IPlugin.Handle.Context> {
+    const pluginExecutor = this.getPluginExecutor()
+    if (!pluginExecutor)
+      throw new Error('[UNIOC] Plugin executor is not set in plugin context.')
+
+    return await pluginExecutor.executeHandle(
+      options.classWrapper,
+      options.propertyKey,
+      options.methodArguments,
+      options.error,
+      'error',
+    )
+  }
 }

packages/core/core/src/types/plugin.ts

@@ -6,13 +6,42 @@ import type { IContainer } from './container'
 import type { IContext } from './context'
 import type { IInternalLogger } from './logger'
 
+export interface IHandleExecutorOptions {
+  /**
+   * The class wrapper.
+   */
+  classWrapper: IClassWrapper
+  /**
+   * The `catch` error.
+   */
+  error: unknown
+  /**
+   * The current method property key.
+   */
+  propertyKey: PropertyKey
+  /**
+   * The current method arguments.
+   */
+  methodArguments: unknown[]
+}
+
 export interface IPluginContext extends IContext, IInternalLogger, IBootstrapDeriver {
   /**
    * ### Get global container
    *
    * 🌏 Get the global container.
    */
   getGlobalContainer(): IContainer
+  /**
+   * ### Handle
+   *
+   * ❌ A function that is used to handle when a class instance method throw an error.
+   * It can pass the error to enter the plugin pipe context.
+   *
+   * @param options - The position information of the `try/catch block`.
+   * @returns The plugin handle context.
+   */
+  handle(options: IHandleExecutorOptions): Promise<IPlugin.Handle.Context>
 }
 
 export interface IPlugin {

packages/core/core/test/index.test.ts

@@ -29,10 +29,16 @@ describe('plugin Testing', () => {
         expect(this.childPropertyService).toBeInstanceOf(ChildService)
         expect(this.childPropertyService.foo).toBe('bar')
       }
+
+      willThrowError() {
+        throw new Error('Test error!')
+      }
     }
 
     class TestingApp extends AbstractBootstrap {
       async run(): Promise<void> {
+        let hasWillThrowError = false
+
         super.use({
           name: 'test',
 
@@ -42,6 +48,19 @@ describe('plugin Testing', () => {
             const testServiceInstance = await testClassWrapper.resolve()
             expect(testServiceInstance).toBeInstanceOf(TestService)
 
+            // Custom error handler
+            try {
+              testServiceInstance.willThrowError()
+            }
+            catch (error) {
+              await this.handle({
+                classWrapper: testClassWrapper,
+                error,
+                propertyKey: 'willThrowError',
+                methodArguments: [],
+              })
+            }
+
             const testValueWrapper = bootstrap.createValue('test-value', 'test-value-token')
             expect(isValueWrapper(testValueWrapper)).toBe(true)
             expect(testValueWrapper.getValue()).toBe('test-value')
@@ -153,9 +172,14 @@ describe('plugin Testing', () => {
               expect(ctx.getPropertyKey()).toBe('onReady')
               expect(ctx.getMethodArguments()).toEqual(['test-arg-in-invoke-hook'])
             }
+
+            if (ctx.getPropertyKey() === 'willThrowError') {
+              hasWillThrowError = true
+            }
           },
         })
         await super.initialize()
+        expect(hasWillThrowError).toBe(true)
       }
     }