type-graphql 2.0.0-rc.2 → 2.0.0-rc.4

package/build/esm/metadata/metadata-storage.js

@@ -7,23 +7,34 @@ export class MetadataStorage {
         this.subscriptions = [];
         this.fieldResolvers = [];
         this.objectTypes = [];
+        this.objectTypesCache = new Map();
         this.inputTypes = [];
         this.argumentTypes = [];
         this.interfaceTypes = [];
+        this.interfaceTypesCache = new Map();
         this.authorizedFields = [];
+        this.authorizedFieldsByTargetAndFieldCache = new Map();
         this.authorizedResolver = [];
+        this.authorizedResolverByTargetCache = new Map();
         this.enums = [];
         this.unions = [];
         this.middlewares = [];
+        this.middlewaresByTargetAndFieldCache = new Map();
         this.resolverMiddlewares = [];
+        this.resolverMiddlewaresByTargetCache = new Map();
         this.classDirectives = [];
+        this.classDirectivesByTargetCache = new Map();
         this.fieldDirectives = [];
+        this.fieldDirectivesByTargetAndFieldCache = new Map();
         this.argumentDirectives = [];
         this.classExtensions = [];
         this.fieldExtensions = [];
         this.resolverClasses = [];
+        this.resolverClassesCache = new Map();
         this.fields = [];
+        this.fieldsCache = new Map();
         this.params = [];
+        this.paramsCache = new Map();
     }
     collectQueryHandlerMetadata(definition) {
         this.queries.push(definition);
@@ -96,12 +107,127 @@ export class MetadataStorage {
     collectExtensionsFieldMetadata(definition) {
         this.fieldExtensions.push(definition);
     }
+    initCache() {
+        this.clearMapCaches();
+        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 => {
+                if (!this.paramsCache.has(param.target)) {
+                    this.paramsCache.set(param.target, new Map());
+                }
+                if (!this.paramsCache.get(param.target).has(param.methodName)) {
+                    this.paramsCache.get(param.target).set(param.methodName, []);
+                }
+                this.paramsCache.get(param.target).get(param.methodName).push(param);
+            });
+        }
+        if (this.middlewares?.length) {
+            this.middlewares.forEach(middleware => {
+                if (!this.middlewaresByTargetAndFieldCache.has(middleware.target)) {
+                    this.middlewaresByTargetAndFieldCache.set(middleware.target, new Map());
+                }
+                if (!this.middlewaresByTargetAndFieldCache.get(middleware.target).has(middleware.fieldName)) {
+                    this.middlewaresByTargetAndFieldCache
+                        .get(middleware.target)
+                        .set(middleware.fieldName, new Set());
+                }
+                if (!this.middlewaresByTargetAndFieldCache
+                    .get(middleware.target)
+                    .get(middleware.fieldName)
+                    .has(middleware)) {
+                    this.middlewaresByTargetAndFieldCache
+                        .get(middleware.target)
+                        .get(middleware.fieldName)
+                        .add(middleware);
+                }
+            });
+        }
+        if (this.resolverMiddlewares?.length) {
+            this.resolverMiddlewares.forEach(middleware => {
+                const key = middleware.target;
+                if (!this.resolverMiddlewaresByTargetCache.has(key)) {
+                    this.resolverMiddlewaresByTargetCache.set(key, new Set());
+                }
+                if (!this.resolverMiddlewaresByTargetCache.get(key).has(middleware)) {
+                    this.resolverMiddlewaresByTargetCache.get(key).add(middleware);
+                }
+            });
+        }
+        if (this.fieldDirectives?.length) {
+            this.fieldDirectives.forEach(directive => {
+                if (!this.fieldDirectivesByTargetAndFieldCache.has(directive.target)) {
+                    this.fieldDirectivesByTargetAndFieldCache.set(directive.target, new Map());
+                }
+                if (!this.fieldDirectivesByTargetAndFieldCache.get(directive.target).has(directive.fieldName)) {
+                    this.fieldDirectivesByTargetAndFieldCache
+                        .get(directive.target)
+                        .set(directive.fieldName, []);
+                }
+                this.fieldDirectivesByTargetAndFieldCache
+                    .get(directive.target)
+                    .get(directive.fieldName)
+                    .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 => {
+                if (!this.authorizedFieldsByTargetAndFieldCache.has(field.target)) {
+                    this.authorizedFieldsByTargetAndFieldCache.set(field.target, new Map());
+                }
+                if (!this.authorizedFieldsByTargetAndFieldCache.get(field.target).has(field.fieldName)) {
+                    this.authorizedFieldsByTargetAndFieldCache.get(field.target).set(field.fieldName, 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) {
         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);
@@ -135,29 +261,69 @@ export class MetadataStorage {
         this.resolverClasses = [];
         this.fields = [];
         this.params = [];
+        this.clearMapCaches();
+    }
+    clone() {
+        const cloned = new MetadataStorage();
+        cloned.queries = [...this.queries];
+        cloned.mutations = [...this.mutations];
+        cloned.subscriptions = [...this.subscriptions];
+        cloned.fieldResolvers = [...this.fieldResolvers];
+        cloned.objectTypes = [...this.objectTypes];
+        cloned.inputTypes = [...this.inputTypes];
+        cloned.argumentTypes = [...this.argumentTypes];
+        cloned.interfaceTypes = [...this.interfaceTypes];
+        cloned.authorizedFields = [...this.authorizedFields];
+        cloned.authorizedResolver = [...this.authorizedResolver];
+        cloned.enums = [...this.enums];
+        cloned.unions = [...this.unions];
+        cloned.middlewares = [...this.middlewares];
+        cloned.resolverMiddlewares = [...this.resolverMiddlewares];
+        cloned.classDirectives = [...this.classDirectives];
+        cloned.fieldDirectives = [...this.fieldDirectives];
+        cloned.argumentDirectives = [...this.argumentDirectives];
+        cloned.classExtensions = [...this.classExtensions];
+        cloned.fieldExtensions = [...this.fieldExtensions];
+        cloned.resolverClasses = [...this.resolverClasses];
+        cloned.fields = [...this.fields];
+        cloned.params = [...this.params];
+        return cloned;
+    }
+    clearMapCaches() {
+        this.fieldsCache = new Map();
+        this.objectTypesCache = new Map();
+        this.interfaceTypesCache = new Map();
+        this.middlewaresByTargetAndFieldCache = new Map();
+        this.resolverMiddlewaresByTargetCache = new Map();
+        this.paramsCache = new Map();
+        this.fieldDirectivesByTargetAndFieldCache = new Map();
+        this.classDirectivesByTargetCache = new Map();
+        this.authorizedFieldsByTargetAndFieldCache = new Map();
+        this.authorizedResolverByTargetCache = new Map();
+        this.resolverClassesCache = new Map();
     }
     buildClassMetadata(definitions) {
         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);
+                    field.params = this.paramsCache.get(field.target)?.get(field.name) || [];
                     field.middlewares = [
-                        ...mapMiddlewareMetadataToArray(this.resolverMiddlewares.filter(middleware => middleware.target === field.target)),
-                        ...mapMiddlewareMetadataToArray(this.middlewares.filter(middleware => middleware.target === field.target && middleware.fieldName === field.name)),
+                        ...mapMiddlewareMetadataToArray([
+                            ...(this.resolverMiddlewaresByTargetCache.get(field.target) || []),
+                        ]),
+                        ...mapMiddlewareMetadataToArray([
+                            ...(this.middlewaresByTargetAndFieldCache.get(field.target)?.get(field.name) || []),
+                        ]),
                     ];
-                    field.directives = this.fieldDirectives
-                        .filter(it => it.target === field.target && it.fieldName === field.name)
-                        .map(it => it.directive);
+                    field.directives = (this.fieldDirectivesByTargetAndFieldCache.get(field.target)?.get(field.name) || []).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);
+                def.directives = (this.classDirectivesByTargetCache.get(def.target) || []).map(it => it.directive);
             }
             if (!def.extensions) {
                 def.extensions = this.findExtensions(def.target);
@@ -166,17 +332,18 @@ export class MetadataStorage {
     }
     buildResolversMetadata(definitions) {
         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)?.get(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)),
+                ...mapMiddlewareMetadataToArray([
+                    ...(this.resolverMiddlewaresByTargetCache.get(def.target) || []),
+                ]),
+                ...mapMiddlewareMetadataToArray([
+                    ...(this.middlewaresByTargetAndFieldCache.get(def.target)?.get(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)?.get(def.methodName) || []).map(it => it.directive);
             def.extensions = this.findExtensions(def.target, def.methodName);
         });
     }
@@ -184,19 +351,15 @@ 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)?.get(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;
             if (def.kind === "external") {
-                const typeClass = this.resolverClasses.find(resolver => resolver.target === def.target)
-                    .getObjectType();
-                const typeMetadata = this.objectTypes.find(objTypeDef => objTypeDef.target === typeClass) ||
-                    this.interfaceTypes.find(interfaceTypeDef => interfaceTypeDef.target === typeClass);
+                const typeClass = this.resolverClassesCache.get(def.target).getObjectType();
+                const typeMetadata = 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}'`);
                 }
@@ -247,7 +410,7 @@ export class MetadataStorage {
         this.resolverClasses.forEach(def => {
             let superResolver = Object.getPrototypeOf(def.target);
             while (superResolver.prototype) {
-                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);
@@ -259,7 +422,8 @@ export class MetadataStorage {
         });
     }
     findFieldRoles(target, fieldName) {
-        const authorizedField = this.authorizedFields.find(authField => authField.target === target && authField.fieldName === fieldName) ?? this.authorizedResolver.find(authScope => authScope.target === target);
+        const authorizedField = this.authorizedFieldsByTargetAndFieldCache.get(target)?.get(fieldName) ||
+            this.authorizedResolverByTargetCache.get(target);
         if (!authorizedField) {
             return undefined;
         }

package/build/esm/schema/schema-generator.js

@@ -3,7 +3,6 @@ import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLO
 import { CannotDetermineGraphQLTypeError, ConflictingDefaultValuesError, GeneratingSchemaError, InterfaceResolveTypeError, MissingPubSubError, MissingSubscriptionTopicsError, UnionResolveTypeError, } from "../errors/index.js";
 import { convertTypeIfScalar, getEnumValuesMap, wrapWithTypeOptions } from "../helpers/types.js";
 import { getMetadataStorage } from "../metadata/getMetadataStorage.js";
-import { MetadataStorage } from "../metadata/metadata-storage.js";
 import { createAdvancedFieldResolver, createBasicFieldResolver, createHandlerResolver, wrapResolverWithAuthChecker, } from "../resolvers/create.js";
 import { ensureInstalledCorrectGraphQLPackage } from "../utils/graphql-version.js";
 import { BuildContext } from "./build-context.js";
@@ -11,7 +10,7 @@ import { getFieldDefinitionNode, getInputObjectTypeDefinitionNode, getInputValue
 import { getFieldMetadataFromInputType, getFieldMetadataFromObjectType } from "./utils.js";
 export class SchemaGenerator {
     static generateFromMetadata(options) {
-        this.metadataStorage = Object.assign(new MetadataStorage(), getMetadataStorage());
+        this.metadataStorage = getMetadataStorage().clone();
         this.metadataStorage.build(options);
         this.checkForErrors(options);
         BuildContext.create(options);
@@ -29,6 +28,11 @@ export class SchemaGenerator {
         });
         BuildContext.reset();
         this.usedInterfaceTypes = new Set();
+        this.objectTypesInfoMap = new Map();
+        this.inputTypesInfoMap = new Map();
+        this.interfaceTypesInfoMap = new Map();
+        this.enumTypesInfoMap = new Map();
+        this.unionTypesInfoMap = new Map();
         if (!options.skipCheck) {
             const { errors } = graphqlSync({ schema: finalSchema, source: getIntrospectionQuery() });
             if (errors) {
@@ -59,15 +63,15 @@ export class SchemaGenerator {
             : defaultValueFromInitializer;
     }
     static buildTypesInfo(resolvers) {
-        this.unionTypesInfo = this.metadataStorage.unions.map(unionMetadata => {
+        this.unionTypesInfoMap = new Map(this.metadataStorage.unions.map(unionMetadata => {
             const unionObjectTypesInfo = [];
             const typesThunk = () => {
                 unionObjectTypesInfo.push(...unionMetadata
                     .getClassTypes()
-                    .map(objectTypeCls => this.objectTypesInfo.find(type => type.target === objectTypeCls)));
+                    .map(objectTypeCls => this.objectTypesInfoMap.get(objectTypeCls)));
                 return unionObjectTypesInfo.map(it => it.type);
             };
-            return {
+            const unionTypeInfo = {
                 unionSymbol: unionMetadata.symbol,
                 type: new GraphQLUnionType({
                     name: unionMetadata.name,
@@ -87,10 +91,11 @@ export class SchemaGenerator {
                         },
                 }),
             };
-        });
-        this.enumTypesInfo = this.metadataStorage.enums.map(enumMetadata => {
+            return [unionMetadata.symbol, unionTypeInfo];
+        }));
+        this.enumTypesInfoMap = new Map(this.metadataStorage.enums.map(enumMetadata => {
             const enumMap = getEnumValuesMap(enumMetadata.enumObj);
-            return {
+            const enumTypeInfo = {
                 enumObj: enumMetadata.enumObj,
                 type: new GraphQLEnumType({
                     name: enumMetadata.name,
@@ -106,17 +111,18 @@ export class SchemaGenerator {
                     }, {}),
                 }),
             };
-        });
-        this.objectTypesInfo = this.metadataStorage.objectTypes.map(objectType => {
+            return [enumMetadata.enumObj, enumTypeInfo];
+        }));
+        this.objectTypesInfoMap = new Map(this.metadataStorage.objectTypes.map(objectType => {
             const objectSuperClass = Object.getPrototypeOf(objectType.target);
             const hasExtended = objectSuperClass.prototype !== undefined;
             const getSuperClassType = () => {
-                const superClassTypeInfo = this.objectTypesInfo.find(type => type.target === objectSuperClass) ??
-                    this.interfaceTypesInfo.find(type => type.target === objectSuperClass);
+                const superClassTypeInfo = this.objectTypesInfoMap.get(objectSuperClass) ??
+                    this.interfaceTypesInfoMap.get(objectSuperClass);
                 return superClassTypeInfo ? superClassTypeInfo.type : undefined;
             };
             const interfaceClasses = objectType.interfaceClasses || [];
-            return {
+            const objectTypeInfo = {
                 metadata: objectType,
                 target: objectType.target,
                 type: new GraphQLObjectType({
@@ -126,7 +132,7 @@ export class SchemaGenerator {
                     extensions: objectType.extensions,
                     interfaces: () => {
                         let interfaces = interfaceClasses.map(interfaceClass => {
-                            const interfaceTypeInfo = this.interfaceTypesInfo.find(info => info.target === interfaceClass);
+                            const interfaceTypeInfo = this.interfaceTypesInfoMap.get(interfaceClass);
                             if (!interfaceTypeInfo) {
                                 throw new Error(`Cannot find interface type metadata for class '${interfaceClass.name}' ` +
                                     `provided in 'implements' option for '${objectType.target.name}' object type class. ` +
@@ -192,28 +198,30 @@ export class SchemaGenerator {
                     },
                 }),
             };
-        });
-        this.interfaceTypesInfo = this.metadataStorage.interfaceTypes.map(interfaceType => {
+            return [objectType.target, objectTypeInfo];
+        }));
+        this.interfaceTypesInfoMap = new Map(this.metadataStorage.interfaceTypes.map(interfaceType => {
             const interfaceSuperClass = Object.getPrototypeOf(interfaceType.target);
             const hasExtended = interfaceSuperClass.prototype !== undefined;
             const getSuperClassType = () => {
-                const superClassTypeInfo = this.interfaceTypesInfo.find(type => type.target === interfaceSuperClass);
+                const superClassTypeInfo = this.interfaceTypesInfoMap.get(interfaceSuperClass);
                 return superClassTypeInfo ? superClassTypeInfo.type : undefined;
             };
             const implementingObjectTypesTargets = this.metadataStorage.objectTypes
                 .filter(objectType => objectType.interfaceClasses &&
                 objectType.interfaceClasses.includes(interfaceType.target))
                 .map(objectType => objectType.target);
-            const implementingObjectTypesInfo = this.objectTypesInfo.filter(objectTypesInfo => implementingObjectTypesTargets.includes(objectTypesInfo.target));
-            return {
+            const implementingObjectTypesInfo = [...this.objectTypesInfoMap.values()].filter(objectTypesInfo => implementingObjectTypesTargets.includes(objectTypesInfo.target));
+            const interfaceTypeInfo = {
                 metadata: interfaceType,
                 target: interfaceType.target,
                 type: new GraphQLInterfaceType({
                     name: interfaceType.name,
                     description: interfaceType.description,
                     astNode: getInterfaceTypeDefinitionNode(interfaceType.name, interfaceType.directives),
+                    extensions: interfaceType.extensions,
                     interfaces: () => {
-                        let interfaces = (interfaceType.interfaceClasses || []).map(interfaceClass => this.interfaceTypesInfo.find(info => info.target === interfaceClass).type);
+                        let interfaces = (interfaceType.interfaceClasses || []).map(interfaceClass => this.interfaceTypesInfoMap.get(interfaceClass).type);
                         if (hasExtended) {
                             const superClass = getSuperClassType();
                             if (superClass) {
@@ -273,15 +281,16 @@ export class SchemaGenerator {
                         },
                 }),
             };
-        });
-        this.inputTypesInfo = this.metadataStorage.inputTypes.map(inputType => {
+            return [interfaceType.target, interfaceTypeInfo];
+        }));
+        this.inputTypesInfoMap = new Map(this.metadataStorage.inputTypes.map(inputType => {
             const objectSuperClass = Object.getPrototypeOf(inputType.target);
             const getSuperClassType = () => {
-                const superClassTypeInfo = this.inputTypesInfo.find(type => type.target === objectSuperClass);
+                const superClassTypeInfo = this.inputTypesInfoMap.get(objectSuperClass);
                 return superClassTypeInfo ? superClassTypeInfo.type : undefined;
             };
             const inputInstance = new inputType.target();
-            return {
+            const inputTypeInfo = {
                 target: inputType.target,
                 type: new GraphQLInputObjectType({
                     name: inputType.name,
@@ -316,7 +325,8 @@ export class SchemaGenerator {
                     astNode: getInputObjectTypeDefinitionNode(inputType.name, inputType.directives),
                 }),
             };
-        });
+            return [inputType.target, inputTypeInfo];
+        }));
     }
     static buildRootQueryType(resolvers) {
         const queriesHandlers = this.filterHandlersByResolvers(this.metadataStorage.queries, resolvers);
@@ -346,8 +356,8 @@ export class SchemaGenerator {
         });
     }
     static buildOtherTypes(orphanedTypes) {
-        const autoRegisteredObjectTypesInfo = this.objectTypesInfo.filter(typeInfo => typeInfo.metadata.interfaceClasses?.some(interfaceClass => {
-            const implementedInterfaceInfo = this.interfaceTypesInfo.find(it => it.target === interfaceClass);
+        const autoRegisteredObjectTypesInfo = [...this.objectTypesInfoMap.values()].filter(typeInfo => typeInfo.metadata.interfaceClasses?.some(interfaceClass => {
+            const implementedInterfaceInfo = this.interfaceTypesInfoMap.get(interfaceClass);
             if (!implementedInterfaceInfo) {
                 return false;
             }
@@ -360,9 +370,9 @@ export class SchemaGenerator {
             return true;
         }));
         return [
-            ...this.filterTypesInfoByOrphanedTypesAndExtractType(this.objectTypesInfo, orphanedTypes),
-            ...this.filterTypesInfoByOrphanedTypesAndExtractType(this.interfaceTypesInfo, orphanedTypes),
-            ...this.filterTypesInfoByOrphanedTypesAndExtractType(this.inputTypesInfo, orphanedTypes),
+            ...this.filterTypesInfoByOrphanedTypesAndExtractType([...this.objectTypesInfoMap.values()], orphanedTypes),
+            ...this.filterTypesInfoByOrphanedTypesAndExtractType([...this.interfaceTypesInfoMap.values()], orphanedTypes),
+            ...this.filterTypesInfoByOrphanedTypesAndExtractType([...this.inputTypesInfoMap.values()], orphanedTypes),
             ...autoRegisteredObjectTypesInfo.map(typeInfo => typeInfo.type),
         ];
     }
@@ -498,26 +508,26 @@ export class SchemaGenerator {
         let gqlType;
         gqlType = convertTypeIfScalar(type);
         if (!gqlType) {
-            const objectType = this.objectTypesInfo.find(it => it.target === type);
+            const objectType = this.objectTypesInfoMap.get(type);
             if (objectType) {
                 gqlType = objectType.type;
             }
         }
         if (!gqlType) {
-            const interfaceType = this.interfaceTypesInfo.find(it => it.target === type);
+            const interfaceType = this.interfaceTypesInfoMap.get(type);
             if (interfaceType) {
                 this.usedInterfaceTypes.add(interfaceType.target);
                 gqlType = interfaceType.type;
             }
         }
         if (!gqlType) {
-            const enumType = this.enumTypesInfo.find(it => it.enumObj === type);
+            const enumType = this.enumTypesInfoMap.get(type);
             if (enumType) {
                 gqlType = enumType.type;
             }
         }
         if (!gqlType) {
-            const unionType = this.unionTypesInfo.find(it => it.unionSymbol === type);
+            const unionType = this.unionTypesInfoMap.get(type);
             if (unionType) {
                 gqlType = unionType.type;
             }
@@ -532,13 +542,13 @@ export class SchemaGenerator {
         let gqlType;
         gqlType = convertTypeIfScalar(type);
         if (!gqlType) {
-            const inputType = this.inputTypesInfo.find(it => it.target === type);
+            const inputType = this.inputTypesInfoMap.get(type);
             if (inputType) {
                 gqlType = inputType.type;
             }
         }
         if (!gqlType) {
-            const enumType = this.enumTypesInfo.find(it => it.enumObj === type);
+            const enumType = this.enumTypesInfoMap.get(type);
             if (enumType) {
                 gqlType = enumType.type;
             }
@@ -566,9 +576,9 @@ export class SchemaGenerator {
         return typesInfo.filter(it => orphanedTypes.includes(it.target)).map(it => it.type);
     }
 }
-SchemaGenerator.objectTypesInfo = [];
-SchemaGenerator.inputTypesInfo = [];
-SchemaGenerator.interfaceTypesInfo = [];
-SchemaGenerator.enumTypesInfo = [];
-SchemaGenerator.unionTypesInfo = [];
+SchemaGenerator.objectTypesInfoMap = new Map();
+SchemaGenerator.inputTypesInfoMap = new Map();
+SchemaGenerator.interfaceTypesInfoMap = new Map();
+SchemaGenerator.enumTypesInfoMap = new Map();
+SchemaGenerator.unionTypesInfoMap = new Map();
 SchemaGenerator.usedInterfaceTypes = new Set();

package/build/esm/utils/graphql-version.js

@@ -1,7 +1,7 @@
 import * as graphql from "graphql";
 import semVer from "semver";
 import { UnmetGraphQLPeerDependencyError } from "../errors/index.js";
-export const graphQLPeerDependencyVersion = "^16.8.1";
+export const graphQLPeerDependencyVersion = "^16.12.0";
 export function ensureInstalledCorrectGraphQLPackage() {
     if (!semVer.satisfies(graphql.version, graphQLPeerDependencyVersion)) {
         throw new UnmetGraphQLPeerDependencyError(graphql.version, graphQLPeerDependencyVersion);

package/build/typings/metadata/metadata-storage.d.ts

@@ -9,23 +9,34 @@ export declare class MetadataStorage {
     subscriptions: SubscriptionResolverMetadata[];
     fieldResolvers: FieldResolverMetadata[];
     objectTypes: ObjectClassMetadata[];
+    objectTypesCache: Map<Function, ObjectClassMetadata>;
     inputTypes: ClassMetadata[];
     argumentTypes: ClassMetadata[];
     interfaceTypes: InterfaceClassMetadata[];
+    interfaceTypesCache: Map<Function, InterfaceClassMetadata>;
     authorizedFields: AuthorizedMetadata[];
+    authorizedFieldsByTargetAndFieldCache: Map<Function, Map<string, AuthorizedMetadata>>;
     authorizedResolver: AuthorizedClassMetadata[];
+    authorizedResolverByTargetCache: Map<Function, AuthorizedClassMetadata>;
     enums: EnumMetadata[];
     unions: UnionMetadataWithSymbol[];
     middlewares: MiddlewareMetadata[];
+    middlewaresByTargetAndFieldCache: Map<Function, Map<string, Set<MiddlewareMetadata>>>;
     resolverMiddlewares: ResolverMiddlewareMetadata[];
+    resolverMiddlewaresByTargetCache: Map<Function, Set<ResolverMiddlewareMetadata>>;
     classDirectives: DirectiveClassMetadata[];
+    classDirectivesByTargetCache: Map<Function, DirectiveClassMetadata[]>;
     fieldDirectives: DirectiveFieldMetadata[];
+    fieldDirectivesByTargetAndFieldCache: Map<Function, Map<string, DirectiveFieldMetadata[]>>;
     argumentDirectives: DirectiveArgumentMetadata[];
     classExtensions: ExtensionsClassMetadata[];
     fieldExtensions: ExtensionsFieldMetadata[];
     resolverClasses: ResolverClassMetadata[];
+    resolverClassesCache: Map<Function, ResolverClassMetadata>;
     fields: FieldMetadata[];
+    fieldsCache: Map<Function, FieldMetadata[]>;
     params: ParamMetadata[];
+    paramsCache: Map<Function, Map<string, ParamMetadata[]>>;
     collectQueryHandlerMetadata(definition: ResolverMetadata): void;
     collectMutationHandlerMetadata(definition: ResolverMetadata): void;
     collectSubscriptionHandlerMetadata(definition: SubscriptionResolverMetadata): void;
@@ -48,8 +59,11 @@ export declare class MetadataStorage {
     collectDirectiveArgumentMetadata(definition: DirectiveArgumentMetadata): void;
     collectExtensionsClassMetadata(definition: ExtensionsClassMetadata): void;
     collectExtensionsFieldMetadata(definition: ExtensionsFieldMetadata): void;
+    initCache(): void;
     build(options: SchemaGeneratorOptions): void;
     clear(): void;
+    clone(): MetadataStorage;
+    private clearMapCaches;
     private buildClassMetadata;
     private buildResolversMetadata;
     private buildFieldResolverMetadata;

package/build/typings/schema/schema-generator.d.ts

@@ -19,11 +19,11 @@ export type SchemaGeneratorOptions = {
     directives?: GraphQLDirective[];
 } & BuildContextOptions;
 export declare abstract class SchemaGenerator {
-    private static objectTypesInfo;
-    private static inputTypesInfo;
-    private static interfaceTypesInfo;
-    private static enumTypesInfo;
-    private static unionTypesInfo;
+    private static objectTypesInfoMap;
+    private static inputTypesInfoMap;
+    private static interfaceTypesInfoMap;
+    private static enumTypesInfoMap;
+    private static unionTypesInfoMap;
     private static usedInterfaceTypes;
     private static metadataStorage;
     static generateFromMetadata(options: SchemaGeneratorOptions): GraphQLSchema;

package/build/typings/utils/graphql-version.d.ts

@@ -1,2 +1,2 @@
-export declare const graphQLPeerDependencyVersion = "^16.8.1";
+export declare const graphQLPeerDependencyVersion = "^16.12.0";
 export declare function ensureInstalledCorrectGraphQLPackage(): void;