Convert current middleware to new GlobalHttpHooks

Author: CarsonF

src/components/authentication/authentication.module.ts

@@ -1,10 +1,4 @@
-import {
-  forwardRef,
-  Global,
-  MiddlewareConsumer,
-  Module,
-  NestModule,
-} from '@nestjs/common';
+import { forwardRef, Global, Module } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { splitDb } from '~/core';
 import { AuthorizationModule } from '../authorization/authorization.module';
@@ -54,12 +48,4 @@ import { SessionResolver } from './session.resolver';
     AuthenticationRepository,
   ],
 })
-export class AuthenticationModule implements NestModule {
-  constructor(
-    private readonly currentUserProvider: EdgeDBCurrentUserProvider,
-  ) {}
-
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(this.currentUserProvider.use).forRoutes('*');
-  }
-}
+export class AuthenticationModule {}

src/components/authentication/current-user.provider.ts

@@ -9,31 +9,30 @@ import { isUUID } from 'class-validator';
 import { BehaviorSubject, identity } from 'rxjs';
 import { Session } from '~/common';
 import { EdgeDB, OptionsFn } from '~/core/edgedb';
-import { HttpMiddleware } from '~/core/http';
+import { GlobalHttpHook } from '~/core/http';
 
 @Injectable()
-export class EdgeDBCurrentUserProvider
-  implements HttpMiddleware, NestInterceptor
-{
+export class EdgeDBCurrentUserProvider implements NestInterceptor {
   // A map to transfer the options' holder
   // between the creation in middleware and the use in the interceptor.
   private readonly optionsHolderByRequest = new WeakMap<
-    Parameters<HttpMiddleware['use']>[0],
+    Parameters<GlobalHttpHook>[0]['raw'],
     BehaviorSubject<OptionsFn>
   >();
 
   constructor(private readonly edgedb: EdgeDB) {}
 
-  use: HttpMiddleware['use'] = (req, res, next) => {
+  @GlobalHttpHook()
+  onRequest(...[req, _reply, next]: Parameters<GlobalHttpHook>) {
     // Create holder to use later to add current user to globals after it is fetched
     const optionsHolder = new BehaviorSubject<OptionsFn>(identity);
-    this.optionsHolderByRequest.set(req, optionsHolder);
+    this.optionsHolderByRequest.set(req.raw, optionsHolder);
 
     // These options should apply to the entire HTTP/GQL operation.
     // Connect middleware is the only place we get a function which has all of
     // this in scope for the use of an ALS context.
     this.edgedb.usingOptions(optionsHolder, next);
-  };
+  }
 
   /**
    * Connect the session to the options' holder

src/core/tracing/tracing.module.ts

@@ -1,9 +1,4 @@
-import {
-  MiddlewareConsumer,
-  Module,
-  NestModule,
-  OnModuleInit,
-} from '@nestjs/common';
+import { Module, OnModuleInit } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import XRay from 'aws-xray-sdk-core';
 import { ConfigService } from '../config/config.service';
@@ -24,17 +19,13 @@ import { XRayMiddleware } from './xray.middleware';
   ],
   exports: [TracingService],
 })
-export class TracingModule implements OnModuleInit, NestModule {
+export class TracingModule implements OnModuleInit {
   constructor(
     @Logger('xray') private readonly logger: ILogger,
     private readonly config: ConfigService,
     private readonly version: VersionService,
   ) {}
 
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(XRayMiddleware).forRoutes('*');
-  }
-
   async onModuleInit() {
     // Don't use cls-hooked lib. It's old and Node has AsyncLocalStorage now.
     XRay.enableManualMode();

src/core/tracing/xray.middleware.ts

@@ -6,13 +6,13 @@ import {
 } from '@nestjs/common';
 import { GqlExecutionContext } from '@nestjs/graphql';
 import XRay from 'aws-xray-sdk-core';
-import { HttpAdapter, HttpMiddleware as NestMiddleware } from '~/core/http';
+import { GlobalHttpHook, HttpAdapter } from '~/core/http';
 import { ConfigService } from '../config/config.service';
 import { Sampler } from './sampler';
 import { TracingService } from './tracing.service';
 
 @Injectable()
-export class XRayMiddleware implements NestMiddleware, NestInterceptor {
+export class XRayMiddleware implements NestInterceptor {
   constructor(
     private readonly tracing: TracingService,
     private readonly sampler: Sampler,
@@ -23,12 +23,13 @@ export class XRayMiddleware implements NestMiddleware, NestInterceptor {
   /**
    * Setup root segment for request/response.
    */
-  use: NestMiddleware['use'] = (req, res, next) => {
+  @GlobalHttpHook()
+  onRequest(...[req, res, next]: Parameters<GlobalHttpHook>) {
     const traceData = XRay.utils.processTraceData(
       req.headers['x-amzn-trace-id'] as string | undefined,
     );
     const root = new XRay.Segment('cord', traceData.root, traceData.parent);
-    const reqData = new XRay.middleware.IncomingRequestData(req);
+    const reqData = new XRay.middleware.IncomingRequestData(req.raw);
     root.addIncomingRequestData(reqData);
     // Use public DNS as url instead of specific IP
     // @ts-expect-error xray library types suck
@@ -40,7 +41,7 @@ export class XRayMiddleware implements NestMiddleware, NestInterceptor {
       enumerable: false,
     });
 
-    res.on('finish', () => {
+    res.raw.on('finish', () => {
       const status = res.statusCode.toString();
       if (status.startsWith('4')) {
         root.addErrorFlag();
@@ -57,7 +58,7 @@ export class XRayMiddleware implements NestMiddleware, NestInterceptor {
     });
 
     this.tracing.segmentStorage.run(root, next);
-  };
+  }
 
   /**
    * Determine if segment should be traced/sampled.