From 67813b1adabf5029155bf26fcc2222009c0407bc Mon Sep 17 00:00:00 2001
From: waiting <1661926154@qq.com>
Date: Sat, 9 Nov 2024 16:28:14 +0800
Subject: [PATCH] refactor(core):
 MidwayAspectService.interceptPrototypeMethod() with processAsync()

---
 packages/core/src/service/aspectService.ts | 100 +++++++++++++--------
 1 file changed, 62 insertions(+), 38 deletions(-)

diff --git a/packages/core/src/service/aspectService.ts b/packages/core/src/service/aspectService.ts
index 67054419b3d1..d34c2266b69f 100644
--- a/packages/core/src/service/aspectService.ts
+++ b/packages/core/src/service/aspectService.ts
@@ -88,47 +88,15 @@ export class MidwayAspectService {
 
     if (Types.isAsyncFunction(Clz.prototype[methodName])) {
       Clz.prototype[methodName] = async function (...args) {
-        let error, result;
-        const newProceed = (...args) => {
-          return originMethod.apply(this, args);
-        };
-        const joinPoint = {
+        const opts: ProcessAsyncOptions = {
+          args,
+          aspectObjectInput: aspectObject,
           methodName,
+          originMethod,
           target: this,
-          args: args,
-          proceed: newProceed,
-          proceedIsAsyncFunction: true,
-        } as JoinPoint;
-
-        if (typeof aspectObject === 'function') {
-          aspectObject = aspectObject();
-        }
-
-        try {
-          await aspectObject.before?.(joinPoint);
-          if (aspectObject.around) {
-            result = await aspectObject.around(joinPoint);
-          } else {
-            result = await originMethod.call(this, ...joinPoint.args);
-          }
-          joinPoint.proceed = undefined;
-          const resultTemp = await aspectObject.afterReturn?.(
-            joinPoint,
-            result
-          );
-          result = typeof resultTemp === 'undefined' ? result : resultTemp;
-          return result;
-        } catch (err) {
-          joinPoint.proceed = undefined;
-          error = err;
-          if (aspectObject.afterThrow) {
-            await aspectObject.afterThrow(joinPoint, error);
-          } else {
-            throw err;
-          }
-        } finally {
-          await aspectObject.after?.(joinPoint, result, error);
         }
+        const res = await processAsync(opts);
+        return res
       };
     } else {
       Clz.prototype[methodName] = function (...args) {
@@ -174,3 +142,59 @@ export class MidwayAspectService {
     }
   }
 }
+
+interface ProcessAsyncOptions {
+  args: unknown[];
+  aspectObjectInput: IMethodAspect | (() => IMethodAspect);
+  methodName: string;
+  originMethod: Function;
+  target: any;
+}
+async function processAsync(options: ProcessAsyncOptions): Promise<unknown> {
+  const { args, aspectObjectInput, originMethod, methodName, target } = options;
+
+  let error, result;
+  const newProceed = (...args2) => {
+    return originMethod.apply(this, args2);
+  };
+  const joinPoint = {
+    methodName,
+    target,
+    args,
+    proceed: newProceed,
+    proceedIsAsyncFunction: true,
+  } as JoinPoint;
+
+  let aspectObject: IMethodAspect;
+  if (typeof aspectObjectInput === 'function') {
+    aspectObject = aspectObjectInput();
+  } else {
+    aspectObject = aspectObjectInput;
+  }
+
+  try {
+    await aspectObject.before?.(joinPoint);
+    if (aspectObject.around) {
+      result = await aspectObject.around(joinPoint);
+    } else {
+      result = await originMethod.call(this, ...joinPoint.args);
+    }
+    joinPoint.proceed = undefined;
+    const resultTemp = await aspectObject.afterReturn?.(
+      joinPoint,
+      result
+    );
+    result = typeof resultTemp === 'undefined' ? result : resultTemp;
+    return result;
+  } catch (err) {
+    joinPoint.proceed = undefined;
+    error = err;
+    if (aspectObject.afterThrow) {
+      await aspectObject.afterThrow(joinPoint, error);
+    } else {
+      throw err;
+    }
+  } finally {
+    await aspectObject.after?.(joinPoint, result, error);
+  }
+}