Fix non-global class middlewares

Author: MichalLytek

examples/4-middlewares/app.module.ts

@@ -1,18 +1,21 @@
 import { Module } from "@nestjs/common";
 import { ApolloDriver } from "@nestjs/apollo";
 import { TypeGraphQLModule } from "../../src";
-import { LoggingMiddleware } from "./logging/middleware";
 
+import { AppContext } from "./context";
 import RecipeModule from "./recipe/module";
 import LoggingModule from "./logging/module";
+import { GlobalLoggingMiddleware } from "./logging/global-logging-middleware";
 
 @Module({
   imports: [
     TypeGraphQLModule.forRoot({
       driver: ApolloDriver,
       emitSchemaFile: true,
       // register middlewares in settings
-      globalMiddlewares: [LoggingMiddleware],
+      globalMiddlewares: [GlobalLoggingMiddleware],
+      // use fake context
+      context: (): AppContext => ({ user: "Johny Debugger" }),
     }),
     RecipeModule,
     // import module with middleware provider

examples/4-middlewares/context.ts

@@ -0,0 +1,3 @@
+export interface AppContext {
+  user?: string;
+}

examples/4-middlewares/logging/middleware.ts renamed to examples/4-middlewares/logging/global-logging-middleware.ts

@@ -3,12 +3,12 @@ import { MiddlewareInterface, NextFn, ResolverData } from "type-graphql";
 import { LoggingService } from "./service";
 
 @Injectable()
-export class LoggingMiddleware implements MiddlewareInterface {
+export class GlobalLoggingMiddleware implements MiddlewareInterface {
   constructor(private readonly loggingService: LoggingService) {}
 
   async use({ info }: ResolverData, next: NextFn) {
     this.loggingService.writeLog(
-      `${info.parentType.name}.${info.fieldName} resolver executed`,
+      `${info.parentType.name}.${info.fieldName} resolver triggered`,
     );
     return next();
   }

examples/4-middlewares/logging/local-logging-middleware.ts

@@ -0,0 +1,16 @@
+import { Injectable } from "@nestjs/common";
+import { MiddlewareInterface, NextFn, ResolverData } from "type-graphql";
+import { LoggingService } from "./service";
+import { AppContext } from "../context";
+
+@Injectable()
+export class LocalLoggingMiddleware implements MiddlewareInterface<AppContext> {
+  constructor(private readonly loggingService: LoggingService) {}
+
+  async use({ context, info }: ResolverData<AppContext>, next: NextFn) {
+    this.loggingService.writeLog(
+      `${context.user ?? "Somebody"} has accessed ${info.parentType.name}.${info.fieldName}`,
+    );
+    return next();
+  }
+}

examples/4-middlewares/logging/module.ts

@@ -1,13 +1,15 @@
 import { Module } from "@nestjs/common";
-import { LoggingMiddleware } from "./middleware";
+import { GlobalLoggingMiddleware } from "./global-logging-middleware";
 
 import { LoggingService } from "./service";
+import { LocalLoggingMiddleware } from "./local-logging-middleware";
 
 @Module({
   providers: [
     LoggingService,
     // register middleware class as provider
-    LoggingMiddleware,
+    GlobalLoggingMiddleware,
+    LocalLoggingMiddleware,
   ],
 })
 export default class LoggingModule {}

examples/4-middlewares/recipe/resolver.ts

@@ -1,8 +1,9 @@
 import { Injectable } from "@nestjs/common";
-import { Resolver, Query, Mutation, Arg } from "type-graphql";
+import { Resolver, Query, Mutation, Arg, UseMiddleware } from "type-graphql";
 
 import RecipeService from "./service";
 import Recipe from "./type";
+import { LocalLoggingMiddleware } from "../logging/local-logging-middleware";
 
 @Injectable()
 @Resolver()
@@ -14,6 +15,7 @@ export default class RecipeResolver {
     return this.recipeService.getRecipes();
   }
 
+  @UseMiddleware(LocalLoggingMiddleware)
   @Mutation(returns => Recipe)
   addRecipe(@Arg("input") recipe: Recipe) {
     this.recipeService.addRecipe(recipe);

src/prepare-options.service.ts

@@ -3,7 +3,6 @@ import { ModulesContainer, ModuleRef, ContextIdFactory } from "@nestjs/core";
 import { REQUEST_CONTEXT_ID } from "@nestjs/core/router/request/request-constants";
 import { InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
 import { ClassType, ContainerType, getMetadataStorage } from "type-graphql";
-import { type Middleware } from "type-graphql/build/typings/typings/middleware";
 
 import { TypeGraphQLFeatureModuleOptions } from "./types";
 
@@ -14,17 +13,10 @@ export default class OptionsPreparatorService {
     private readonly modulesContainer: ModulesContainer,
   ) {}
 
-  prepareOptions(
-    featureModuleToken: string,
-    globalMiddlewares: Middleware<any>[] = [],
-  ) {
+  prepareOptions(featureModuleToken: string) {
     const globalResolvers = getMetadataStorage().resolverClasses.map(
       metadata => metadata.target,
     );
-    const globalMiddlewareClasses = globalMiddlewares.filter(
-      it => it.prototype,
-    ) as Function[];
-
     const featureModuleOptionsArray: TypeGraphQLFeatureModuleOptions[] = [];
     const resolversClasses: ClassType[] = [];
     const providersMetadataMap = new Map<Function, InstanceWrapper<any>>();
@@ -40,12 +32,9 @@ export default class OptionsPreparatorService {
           );
         }
         if (globalResolvers.includes(provider.metatype)) {
-          providersMetadataMap.set(provider.metatype, provider);
           resolversClasses.push(provider.metatype as ClassType);
         }
-        if (globalMiddlewareClasses.includes(provider.metatype)) {
-          providersMetadataMap.set(provider.metatype, provider);
-        }
+        providersMetadataMap.set(provider.metatype, provider);
       }
     }
 

src/typegraphql-options.factory.ts

@@ -27,11 +27,10 @@ export default class TypeGraphQLOptionsFactory implements GqlOptionsFactory {
   ) {}
 
   async createGqlOptions(): Promise<GqlModuleOptions> {
-    const { globalMiddlewares, federationVersion } = this.rootModuleOptions;
+    const { federationVersion } = this.rootModuleOptions;
     const { resolversClasses, container, orphanedTypes, referenceResolvers } =
       this.optionsPreparatorService.prepareOptions(
         TYPEGRAPHQL_FEATURE_MODULE_OPTIONS,
-        globalMiddlewares,
       );
 
     const isFederatedModule =