Merge pull request #3325 from SeedCompany/no-middleware

Author: CarsonF

.eslintrc.cjs

@@ -79,9 +79,9 @@ const restrictedImports = [
     replacement: { path: '~/core/http' },
   },
   {
-    importNames: 'NestMiddleware',
+    importNames: ['NestMiddleware', 'NestModule'],
     path: '@nestjs/common',
-    replacement: { importName: 'HttpMiddleware', path: '~/core/http' },
+    message: 'Do not use express/connect middleware',
   },
   {
     importNames: ['RouteConfig', 'RouteConstraints'],

src/common/discovery-unique-methods.ts

@@ -0,0 +1,25 @@
+import { DiscoveredMethodWithMeta } from '@golevelup/nestjs-discovery';
+
+export const uniqueDiscoveredMethods = <T>(
+  methods: Array<DiscoveredMethodWithMeta<T>>,
+) => {
+  const seenClasses = new Map<object, Map<string, Set<unknown>>>();
+  const uniqueMethods = [] as typeof methods;
+  for (const method of methods) {
+    const clsInstance = method.discoveredMethod.parentClass.instance;
+    const methodName = method.discoveredMethod.methodName;
+    if (!seenClasses.has(clsInstance)) {
+      seenClasses.set(clsInstance, new Map());
+    }
+    const seenMethods = seenClasses.get(clsInstance)!;
+    if (!seenMethods.has(methodName)) {
+      seenMethods.set(methodName, new Set());
+    }
+    const seenMetadata = seenMethods.get(methodName)!;
+    if (!seenMetadata.has(method.meta)) {
+      seenMetadata.add(method.meta);
+      uniqueMethods.push(method);
+    }
+  }
+  return uniqueMethods;
+};

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/graphql/driver.ts

@@ -20,7 +20,7 @@ export class Driver extends YogaDriver<'fastify'> {
     );
     options.plugins = [
       ...(options.plugins ?? []),
-      ...discoveredPlugins.map((cls) => cls.discoveredClass.instance),
+      ...new Set(discoveredPlugins.map((cls) => cls.discoveredClass.instance)),
     ];
 
     await super.start(options);

src/core/http/decorators.ts

@@ -6,6 +6,7 @@ import { Many } from '@seedcompany/common';
 import { createMetadataDecorator } from '@seedcompany/nest';
 import { FastifyContextConfig } from 'fastify';
 import type { RouteConstraint } from 'fastify/types/route';
+import { HttpHooks } from './types';
 
 export const RouteConstraints = createMetadataDecorator({
   key: FASTIFY_ROUTE_CONSTRAINTS_METADATA,
@@ -54,3 +55,10 @@ export const RawBody = createMetadataDecorator({
     } = {},
   ) => config,
 });
+
+export const GlobalHttpHook = createMetadataDecorator({
+  types: ['method'],
+  setter: (hook: keyof HttpHooks = 'preHandler') => hook,
+});
+export type GlobalHttpHook<Name extends keyof HttpHooks = 'preHandler'> =
+  HttpHooks[Name];

src/core/http/http.adapter.ts

@@ -1,6 +1,7 @@
 import compression from '@fastify/compress';
 import cookieParser from '@fastify/cookie';
 import cors from '@fastify/cors';
+import { DiscoveryService } from '@golevelup/nestjs-discovery';
 import {
   VERSION_NEUTRAL,
   type VersionValue,
@@ -14,9 +15,15 @@ import {
 import type { FastifyInstance, HTTPMethods, RouteOptions } from 'fastify';
 import rawBody from 'fastify-raw-body';
 import * as zlib from 'node:zlib';
+import { uniqueDiscoveredMethods } from '~/common/discovery-unique-methods';
 import { ConfigService } from '~/core/config/config.service';
-import { RawBody, RouteConfig, RouteConstraints } from './decorators';
-import type { CookieOptions, CorsOptions, IResponse } from './types';
+import {
+  GlobalHttpHook,
+  RawBody,
+  RouteConfig,
+  RouteConstraints,
+} from './decorators';
+import type { CookieOptions, CorsOptions, HttpHooks, IResponse } from './types';
 
 export type NestHttpApplication = NestFastifyApplication & {
   configure: (
@@ -61,6 +68,18 @@ export class HttpAdapter extends PatchedFastifyAdapter {
     app.setGlobalPrefix(config.hostUrl$.value.pathname.slice(1));
 
     config.applyTimeouts(app.getHttpServer(), config.httpTimeouts);
+
+    // Attach hooks
+    const globalHooks = await app
+      .get(DiscoveryService)
+      .providerMethodsWithMetaAtKey<keyof HttpHooks>(GlobalHttpHook.KEY);
+    const fastify = app.getHttpAdapter().getInstance();
+    for (const globalHook of uniqueDiscoveredMethods(globalHooks)) {
+      const handler = globalHook.discoveredMethod.handler.bind(
+        globalHook.discoveredMethod.parentClass.instance,
+      );
+      fastify.addHook(globalHook.meta, handler);
+    }
   }
 
   protected injectRouteOptions(
@@ -117,6 +136,13 @@ export class HttpAdapter extends PatchedFastifyAdapter {
     return this.instance.route(route);
   }
 
+  override registerMiddie() {
+    // no
+  }
+  override createMiddlewareFactory(): never {
+    throw new Error('Express/Connect Middleware should not be used');
+  }
+
   setCookie(
     response: IResponse,
     name: string,

src/core/http/types.ts

@@ -1,16 +1,20 @@
 /* eslint-disable @typescript-eslint/method-signature-style */
-// eslint-disable-next-line @seedcompany/no-restricted-imports
-import type { NestMiddleware } from '@nestjs/common';
 import type {
   FastifyRequest as Request,
   FastifyReply as Response,
+  RouteShorthandOptions,
 } from 'fastify';
 import type { Session } from '~/common';
 
 // Exporting with I prefix to avoid ambiguity with web global types
 export type { Request as IRequest, Response as IResponse };
 
-export type HttpMiddleware = NestMiddleware<Request['raw'], Response['raw']>;
+export type HttpHooks = Required<{
+  [Hook in keyof RouteShorthandOptions as Exclude<
+    Extract<Hook, `${'pre' | 'on'}${string}`>,
+    `${'prefix'}${string}`
+  >]: Exclude<RouteShorthandOptions[Hook], any[]>;
+}>;
 
 export { FastifyCorsOptions as CorsOptions } from '@fastify/cors';
 export { SerializeOptions as CookieOptions } from '@fastify/cookie';

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.