feat: Optimize metadata-storage build with HashMap caching for O(1) lookups

Author: benminer

package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-graphql",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.3",
   "private": false,
   "description": "Create GraphQL schema and resolvers with TypeScript, using classes and decorators!",
   "keywords": [

src/metadata/metadata-storage.ts

@@ -46,28 +46,44 @@ export class MetadataStorage {
 
   objectTypes: ObjectClassMetadata[] = [];
 
+  objectTypesCache = new Map<Function, ObjectClassMetadata>();
+
   inputTypes: ClassMetadata[] = [];
 
   argumentTypes: ClassMetadata[] = [];
 
   interfaceTypes: InterfaceClassMetadata[] = [];
 
+  interfaceTypesCache = new Map<Function, InterfaceClassMetadata>();
+
   authorizedFields: AuthorizedMetadata[] = [];
 
+  authorizedFieldsByTargetAndFieldCache = new Map<any, AuthorizedMetadata>();
+
   authorizedResolver: AuthorizedClassMetadata[] = [];
 
+  authorizedResolverByTargetCache = new Map<Function, AuthorizedClassMetadata>();
+
   enums: EnumMetadata[] = [];
 
   unions: UnionMetadataWithSymbol[] = [];
 
   middlewares: MiddlewareMetadata[] = [];
 
+  middlewaresByTargetAndFieldCache = new Map<string, MiddlewareMetadata[]>();
+
   resolverMiddlewares: ResolverMiddlewareMetadata[] = [];
 
+  resolverMiddlewaresByTargetCache = new Map<Function, ResolverMiddlewareMetadata[]>();
+
   classDirectives: DirectiveClassMetadata[] = [];
 
+  classDirectivesByTargetCache = new Map<Function, DirectiveClassMetadata[]>();
+
   fieldDirectives: DirectiveFieldMetadata[] = [];
 
+  fieldDirectivesByTargetAndFieldCache = new Map<any, DirectiveFieldMetadata[]>();
+
   argumentDirectives: DirectiveArgumentMetadata[] = [];
 
   classExtensions: ExtensionsClassMetadata[] = [];
@@ -76,10 +92,16 @@ export class MetadataStorage {
 
   resolverClasses: ResolverClassMetadata[] = [];
 
+  resolverClassesCache = new Map<Function, ResolverClassMetadata>();
+
   fields: FieldMetadata[] = [];
 
+  fieldsCache = new Map<any, FieldMetadata[]>();
+
   params: ParamMetadata[] = [];
 
+  paramsCache = new Map<string, ParamMetadata[]>();
+
   collectQueryHandlerMetadata(definition: ResolverMetadata) {
     this.queries.push(definition);
   }
@@ -173,13 +195,114 @@ export class MetadataStorage {
     this.fieldExtensions.push(definition);
   }
 
+  initCache() {
+    if (this.resolverClasses?.length) {
+      this.resolverClasses.forEach(resolverClass => {
+        if (!this.resolverClassesCache.has(resolverClass.target)) {
+          this.resolverClassesCache.set(resolverClass.target, resolverClass);
+        }
+      });
+    }
+
+    if (this.params?.length) {
+      this.params.forEach(param => {
+        const key = `${param.target}-${param.methodName}`;
+        if (!this.paramsCache.has(key)) {
+          this.paramsCache.set(key, []);
+        }
+        this.paramsCache.get(key)?.push(param);
+      });
+    }
+
+    if (this.middlewares?.length) {
+      this.middlewares.forEach(middleware => {
+        const key = `${middleware.target}-${middleware.fieldName}`;
+        if (!this.middlewaresByTargetAndFieldCache.has(key)) {
+          this.middlewaresByTargetAndFieldCache.set(key, []);
+        }
+        this.middlewaresByTargetAndFieldCache.get(key)?.push(middleware);
+      });
+    }
+
+    if (this.resolverMiddlewares?.length) {
+      this.resolverMiddlewares.forEach(middleware => {
+        const key = middleware.target;
+        if (!this.resolverMiddlewaresByTargetCache.has(key)) {
+          this.resolverMiddlewaresByTargetCache.set(key, []);
+        }
+        this.resolverMiddlewaresByTargetCache.get(key)?.push(middleware);
+      });
+    }
+
+    if (this.fieldDirectives?.length) {
+      this.fieldDirectives.forEach(directive => {
+        const key = `${directive.target}-${directive.fieldName}`;
+        if (!this.fieldDirectivesByTargetAndFieldCache.has(key)) {
+          this.fieldDirectivesByTargetAndFieldCache.set(key, []);
+        }
+        this.fieldDirectivesByTargetAndFieldCache.get(key)?.push(directive);
+      });
+    }
+
+    if (this.classDirectives?.length) {
+      this.classDirectives.forEach(directive => {
+        const key = directive.target;
+        if (!this.classDirectivesByTargetCache.has(key)) {
+          this.classDirectivesByTargetCache.set(key, []);
+        }
+        this.classDirectivesByTargetCache.get(key)?.push(directive);
+      });
+    }
+
+    if (this.authorizedFields?.length) {
+      this.authorizedFields.forEach(field => {
+        const key = `${field.target}-${field.fieldName}`;
+        if (!this.authorizedFieldsByTargetAndFieldCache.has(key)) {
+          this.authorizedFieldsByTargetAndFieldCache.set(key, field);
+        }
+      });
+    }
+
+    if (this.authorizedResolver?.length) {
+      this.authorizedResolver.forEach(resolver => {
+        const key = resolver.target;
+        if (!this.authorizedResolverByTargetCache.has(key)) {
+          this.authorizedResolverByTargetCache.set(key, resolver);
+        }
+      });
+    }
+
+    if (this.fields?.length) {
+      this.fields.forEach(field => {
+        if (!this.fieldsCache.has(field.target)) {
+          this.fieldsCache.set(field.target, []);
+        }
+        this.fieldsCache.get(field.target)?.push(field);
+      });
+    }
+
+    if (this.objectTypes?.length) {
+      this.objectTypes.forEach(objType => {
+        this.objectTypesCache.set(objType.target, objType);
+      });
+    }
+
+    if (this.interfaceTypes?.length) {
+      this.interfaceTypes.forEach(interfaceType => {
+        this.interfaceTypesCache.set(interfaceType.target, interfaceType);
+      });
+    }
+  }
+
   build(options: SchemaGeneratorOptions) {
     this.classDirectives.reverse();
     this.fieldDirectives.reverse();
     this.argumentDirectives.reverse();
     this.classExtensions.reverse();
     this.fieldExtensions.reverse();
 
+    this.initCache();
+
     this.buildClassMetadata(this.objectTypes);
     this.buildClassMetadata(this.inputTypes);
     this.buildClassMetadata(this.argumentTypes);
@@ -223,34 +346,33 @@ export class MetadataStorage {
   private buildClassMetadata(definitions: ClassMetadata[]) {
     definitions.forEach(def => {
       if (!def.fields) {
-        const fields = this.fields.filter(field => field.target === def.target);
+        const fields = this.fieldsCache.get(def.target) || [];
         fields.forEach(field => {
           field.roles = this.findFieldRoles(field.target, field.name);
-          field.params = this.params.filter(
-            param => param.target === field.target && field.name === param.methodName,
+
+          const paramKey = `${field.target.name}-${field.name}`;
+          field.params = this.paramsCache.get(paramKey) || [];
+
+          const middlewares1 = this.resolverMiddlewaresByTargetCache.get(field.target) || [];
+          const middlewaresKey = `${field.target.name}-${field.name}`;
+          const middlewares2 = this.middlewaresByTargetAndFieldCache.get(middlewaresKey) || [];
+
+          field.middlewares = mapMiddlewareMetadataToArray(middlewares1).concat(
+            mapMiddlewareMetadataToArray(middlewares2),
           );
-          field.middlewares = [
-            ...mapMiddlewareMetadataToArray(
-              this.resolverMiddlewares.filter(middleware => middleware.target === field.target),
-            ),
-            ...mapMiddlewareMetadataToArray(
-              this.middlewares.filter(
-                middleware =>
-                  middleware.target === field.target && middleware.fieldName === field.name,
-              ),
-            ),
-          ];
-          field.directives = this.fieldDirectives
-            .filter(it => it.target === field.target && it.fieldName === field.name)
-            .map(it => it.directive);
+
+          const directives =
+            this.fieldDirectivesByTargetAndFieldCache.get(`${field.target.name}-${field.name}`) ||
+            [];
+          field.directives = directives.map(it => it.directive);
+
           field.extensions = this.findExtensions(field.target, field.name);
         });
         def.fields = fields;
       }
       if (!def.directives) {
-        def.directives = this.classDirectives
-          .filter(it => it.target === def.target)
-          .map(it => it.directive);
+        const directives = this.classDirectivesByTargetCache.get(def.target) || [];
+        def.directives = directives.map(directive => directive.directive);
       }
       if (!def.extensions) {
         def.extensions = this.findExtensions(def.target);
@@ -260,28 +382,21 @@ export class MetadataStorage {
 
   private buildResolversMetadata(definitions: BaseResolverMetadata[]) {
     definitions.forEach(def => {
-      const resolverClassMetadata = this.resolverClasses.find(
-        resolver => resolver.target === def.target,
-      )!;
-      def.resolverClassMetadata = resolverClassMetadata;
-      def.params = this.params.filter(
-        param => param.target === def.target && def.methodName === param.methodName,
-      );
+      def.resolverClassMetadata = this.resolverClassesCache.get(def.target);
+      def.params = this.paramsCache.get(`${def.target}-${def.methodName}`) || [];
       def.roles = this.findFieldRoles(def.target, def.methodName);
-      def.middlewares = [
-        ...mapMiddlewareMetadataToArray(
-          this.resolverMiddlewares.filter(middleware => middleware.target === def.target),
-        ),
-        ...mapMiddlewareMetadataToArray(
-          this.middlewares.filter(
-            middleware =>
-              middleware.target === def.target && def.methodName === middleware.fieldName,
-          ),
+
+      def.middlewares = mapMiddlewareMetadataToArray(
+        this.resolverMiddlewaresByTargetCache.get(def.target) || [],
+      ).concat(
+        mapMiddlewareMetadataToArray(
+          this.middlewaresByTargetAndFieldCache.get(`${def.target}-${def.methodName}`) || [],
         ),
-      ];
-      def.directives = this.fieldDirectives
-        .filter(it => it.target === def.target && it.fieldName === def.methodName)
-        .map(it => it.directive);
+      );
+
+      def.directives = (
+        this.fieldDirectivesByTargetAndFieldCache.get(`${def.target}-${def.methodName}`) || []
+      ).map(it => it.directive);
       def.extensions = this.findExtensions(def.target, def.methodName);
     });
   }
@@ -293,20 +408,21 @@ export class MetadataStorage {
     this.buildResolversMetadata(definitions);
     definitions.forEach(def => {
       def.roles = this.findFieldRoles(def.target, def.methodName);
-      def.directives = this.fieldDirectives
-        .filter(it => it.target === def.target && it.fieldName === def.methodName)
-        .map(it => it.directive);
+      def.directives = (
+        this.fieldDirectivesByTargetAndFieldCache.get(`${def.target}-${def.methodName}`) || []
+      ).map(it => it.directive);
       def.extensions = this.findExtensions(def.target, def.methodName);
       def.getObjectType =
         def.kind === "external"
-          ? this.resolverClasses.find(resolver => resolver.target === def.target)!.getObjectType
+          ? this.resolverClassesCache.get(def.target)!.getObjectType
           : () => def.target as ClassType;
       if (def.kind === "external") {
-        const typeClass = this.resolverClasses.find(resolver => resolver.target === def.target)!
-          .getObjectType!();
+        const typeClass = this.resolverClassesCache.get(def.target)!.getObjectType!();
+        if (!typeClass) {
+          throw new Error(`Unable to find type class for external resolver ${def.target.name}`);
+        }
         const typeMetadata =
-          this.objectTypes.find(objTypeDef => objTypeDef.target === typeClass) ||
-          this.interfaceTypes.find(interfaceTypeDef => interfaceTypeDef.target === typeClass);
+          this.objectTypesCache.get(typeClass) || this.interfaceTypesCache.get(typeClass);
         if (!typeMetadata) {
           throw new Error(
             `Unable to find type metadata for input type or object type named '${typeClass.name}'`,
@@ -367,8 +483,7 @@ export class MetadataStorage {
 
       // copy and modify metadata of resolver from parent resolver class
       while (superResolver.prototype) {
-        // eslint-disable-next-line @typescript-eslint/no-loop-func
-        const superResolverMetadata = this.resolverClasses.find(it => it.target === superResolver);
+        const superResolverMetadata = this.resolverClassesCache.get(superResolver);
         if (superResolverMetadata) {
           this.queries = mapSuperResolverHandlers(this.queries, superResolver, def);
           this.mutations = mapSuperResolverHandlers(this.mutations, superResolver, def);
@@ -386,9 +501,8 @@ export class MetadataStorage {
 
   private findFieldRoles(target: Function, fieldName: string): any[] | undefined {
     const authorizedField =
-      this.authorizedFields.find(
-        authField => authField.target === target && authField.fieldName === fieldName,
-      ) ?? this.authorizedResolver.find(authScope => authScope.target === target);
+      this.authorizedFieldsByTargetAndFieldCache.get(`${target}-${fieldName}`) ||
+      this.authorizedResolverByTargetCache.get(target);
     if (!authorizedField) {
       return undefined;
     }