feat(nestjs): add interceptor support (#25)

Author: nailiable

packages/adapter/adapter-nestjs/package.json

@@ -58,6 +58,7 @@
     "@unioc/decorator": "workspace:*",
     "@unioc/meta": "workspace:*",
     "@unioc/shared": "workspace:*",
-    "@unioc/web": "workspace:*"
+    "@unioc/web": "workspace:*",
+    "rxjs": "^7.8.2"
   }
 }

packages/adapter/adapter-nestjs/src/restful/restful-handler.ts

@@ -5,7 +5,9 @@ import type { INestJSMethodParamMetadata, NestJSMethodWrapper } from './method-w
 import type { NestJSRestfulScanner } from './restful-scanner'
 import { UnauthorizedException } from '@nestjs/common'
 import { isClass } from '@unioc/shared'
+import { Observable } from 'rxjs'
 import { ExecutionContextBuilder } from '../execution-context-builder'
+import { toResult } from '../utils'
 import { EndingHandler } from './ending-handler'
 import { NestJSMethodOperator } from './method-operator'
 
@@ -156,6 +158,34 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
       throw new UnauthorizedException()
   }
 
+  protected async executeInterceptors(methodWrapper: NestJSMethodWrapper, params: unknown[], observable: Observable<unknown>): Promise<Observable<unknown>> {
+    const controllerTarget = methodWrapper
+      .getControllerOperator()
+      .getControllerWrapper()
+      .getClassWrapper()
+      .getTarget()
+
+    const resolvedInterceptors = await methodWrapper.getControllerOperator().getControllerWrapper().getRestfulScanner().mergeAndResolveToInstance(
+      methodWrapper.getMethodInterceptors(),
+      methodWrapper.getControllerOperator().getControllerInterceptors(),
+    )
+
+    for (const interceptor of resolvedInterceptors) {
+      observable = await interceptor.intercept(
+        new ExecutionContextBuilder(
+          params,
+          'http',
+          controllerTarget,
+          controllerTarget.prototype[methodWrapper.getPropertyKey()],
+        ),
+        {
+          handle: () => observable,
+        },
+      )
+    }
+    return observable
+  }
+
   async initialize(ctx: IRestfulConnect.InitializeContext): Promise<void> {
     const map = await this.getRestfulScanner()
       .getMiddlewareResolver()
@@ -195,10 +225,23 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
       methodArguments = await this.buildParams(methodWrapper, ctx)
       // 2. Execute guards
       await this.executeGuards(methodWrapper, methodArguments)
-      // 3. Execute the controller method
-      const result = await methodWrapper.execute(methodArguments, extraOptions)
-      // 4. TODO: Execute the interceptors
-      // 5. Send the ending response
+      // 3. Execute the controller method in an observable
+      const responseObservable = new Observable((subscribe) => {
+        methodWrapper.execute(methodArguments, extraOptions)
+          .then((result) => {
+            if (result.type === 'result')
+              subscribe.next(result.value)
+            else
+              subscribe.error(result.error)
+            subscribe.complete()
+          })
+          .catch(error => subscribe.error(error))
+      })
+      // 4. Execute the before interceptors
+      const interceptedObservable = await this.executeInterceptors(methodWrapper, methodArguments, responseObservable)
+      // 5. Get the result from the observable
+      const result = await toResult(interceptedObservable)
+      // 6. Send the ending response if not sent
       await this._endingHandler.sendConnectEndingIfNotSent(ctx, result)
     }
     catch (error) {

packages/adapter/adapter-nestjs/src/utils.ts

@@ -0,0 +1,17 @@
+import type { IResult } from '@unioc/shared'
+import type { Observable } from 'rxjs'
+
+/**
+ * ### 🎦 Convert an observable to a promise
+ *
+ * @param observable - The observable to convert
+ * @returns A promise that resolves to the result of the observable
+ */
+export function toResult<T>(observable: Observable<T>): Promise<IResult> {
+  return new Promise((resolve) => {
+    observable.subscribe({
+      next: value => resolve({ type: 'result', value }),
+      error: error => resolve({ type: 'error', error }),
+    })
+  })
+}