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

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

@@ -10,23 +10,34 @@ 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);
@@ -99,12 +110,127 @@ 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);
@@ -138,29 +264,69 @@ 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 = [
-                        ...(0, utils_1.mapMiddlewareMetadataToArray)(this.resolverMiddlewares.filter(middleware => middleware.target === field.target)),
-                        ...(0, utils_1.mapMiddlewareMetadataToArray)(this.middlewares.filter(middleware => middleware.target === field.target && middleware.fieldName === field.name)),
+                        ...(0, utils_1.mapMiddlewareMetadataToArray)([
+                            ...(this.resolverMiddlewaresByTargetCache.get(field.target) || []),
+                        ]),
+                        ...(0, utils_1.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);
@@ -169,17 +335,18 @@ 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 = [
-                ...(0, utils_1.mapMiddlewareMetadataToArray)(this.resolverMiddlewares.filter(middleware => middleware.target === def.target)),
-                ...(0, utils_1.mapMiddlewareMetadataToArray)(this.middlewares.filter(middleware => middleware.target === def.target && def.methodName === middleware.fieldName)),
+                ...(0, utils_1.mapMiddlewareMetadataToArray)([
+                    ...(this.resolverMiddlewaresByTargetCache.get(def.target) || []),
+                ]),
+                ...(0, utils_1.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);
         });
     }
@@ -187,19 +354,15 @@ 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}'`);
                 }
@@ -250,7 +413,7 @@ 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 = (0, utils_1.mapSuperResolverHandlers)(this.queries, superResolver, def);
                     this.mutations = (0, utils_1.mapSuperResolverHandlers)(this.mutations, superResolver, def);
@@ -262,7 +425,8 @@ 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/cjs/metadata/utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureReflectMetadataExists = exports.mapMiddlewareMetadataToArray = exports.mapSuperFieldResolverHandlers = exports.mapSuperResolverHandlers = void 0;
+exports.mapSuperResolverHandlers = mapSuperResolverHandlers;
+exports.mapSuperFieldResolverHandlers = mapSuperFieldResolverHandlers;
+exports.mapMiddlewareMetadataToArray = mapMiddlewareMetadataToArray;
+exports.ensureReflectMetadataExists = ensureReflectMetadataExists;
 const errors_1 = require("../errors");
 const isThrowing_1 = require("../helpers/isThrowing");
 function mapSuperResolverHandlers(definitions, superResolver, resolverMetadata) {
@@ -12,7 +15,6 @@ function mapSuperResolverHandlers(definitions, superResolver, resolverMetadata)
         }
         : metadata);
 }
-exports.mapSuperResolverHandlers = mapSuperResolverHandlers;
 function mapSuperFieldResolverHandlers(definitions, superResolver, resolverMetadata) {
     const superMetadata = mapSuperResolverHandlers(definitions, superResolver, resolverMetadata);
     return superMetadata.map(metadata => metadata.target === superResolver
@@ -24,16 +26,13 @@ function mapSuperFieldResolverHandlers(definitions, superResolver, resolverMetad
         }
         : metadata);
 }
-exports.mapSuperFieldResolverHandlers = mapSuperFieldResolverHandlers;
 function mapMiddlewareMetadataToArray(metadata) {
     return metadata
         .map(m => m.middlewares)
         .reduce((middlewares, resultArray) => resultArray.concat(middlewares), []);
 }
-exports.mapMiddlewareMetadataToArray = mapMiddlewareMetadataToArray;
 function ensureReflectMetadataExists() {
     if (typeof Reflect !== "object" || typeof Reflect.getMetadata !== "function") {
         throw new errors_1.ReflectMetadataMissingError();
     }
 }
-exports.ensureReflectMetadataExists = ensureReflectMetadataExists;

package/build/cjs/resolvers/convert-args.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertArgToInstance = exports.convertArgsToInstance = void 0;
+exports.convertArgsToInstance = convertArgsToInstance;
+exports.convertArgToInstance = convertArgToInstance;
 const types_1 = require("../helpers/types");
 const getMetadataStorage_1 = require("../metadata/getMetadataStorage");
 const generatedTrees = new Map();
@@ -113,10 +114,8 @@ function convertArgsToInstance(argsMetadata, args) {
     }, {});
     return (0, types_1.convertToType)(ArgsClass, transformedFields);
 }
-exports.convertArgsToInstance = convertArgsToInstance;
 function convertArgToInstance(argMetadata, args) {
     const argValue = args[argMetadata.name];
     const argTarget = argMetadata.getType();
     return convertValuesToInstances(argTarget, argValue);
 }
-exports.convertArgToInstance = convertArgToInstance;

package/build/cjs/resolvers/create.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapResolverWithAuthChecker = exports.createBasicFieldResolver = exports.createAdvancedFieldResolver = exports.createHandlerResolver = void 0;
+exports.createHandlerResolver = createHandlerResolver;
+exports.createAdvancedFieldResolver = createAdvancedFieldResolver;
+exports.createBasicFieldResolver = createBasicFieldResolver;
+exports.wrapResolverWithAuthChecker = wrapResolverWithAuthChecker;
 const auth_middleware_1 = require("../helpers/auth-middleware");
 const types_1 = require("../helpers/types");
 const build_context_1 = require("../schema/build-context");
@@ -32,7 +35,6 @@ function createHandlerResolver(resolverMetadata) {
         });
     };
 }
-exports.createHandlerResolver = createHandlerResolver;
 function createAdvancedFieldResolver(fieldResolverMetadata) {
     if (fieldResolverMetadata.kind === "external") {
         return createHandlerResolver(fieldResolverMetadata);
@@ -57,7 +59,6 @@ function createAdvancedFieldResolver(fieldResolverMetadata) {
         });
     };
 }
-exports.createAdvancedFieldResolver = createAdvancedFieldResolver;
 function createBasicFieldResolver(fieldMetadata) {
     const { authChecker, authMode, globalMiddlewares, container } = build_context_1.BuildContext;
     const middlewares = globalMiddlewares.concat(fieldMetadata.middlewares);
@@ -67,7 +68,6 @@ function createBasicFieldResolver(fieldMetadata) {
         return (0, helpers_1.applyMiddlewares)(container, resolverData, middlewares, () => root[fieldMetadata.name]);
     };
 }
-exports.createBasicFieldResolver = createBasicFieldResolver;
 function wrapResolverWithAuthChecker(resolver, container, roles) {
     const { authChecker, authMode } = build_context_1.BuildContext;
     if (!authChecker || !roles) {
@@ -78,4 +78,3 @@ function wrapResolverWithAuthChecker(resolver, container, roles) {
         return (0, auth_middleware_1.AuthMiddleware)(authChecker, container, authMode, roles)(resolverData, async () => resolver(root, args, context, info));
     };
 }
-exports.wrapResolverWithAuthChecker = wrapResolverWithAuthChecker;

package/build/cjs/resolvers/helpers.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyMiddlewares = exports.applyAuthChecker = exports.getParams = void 0;
+exports.getParams = getParams;
+exports.applyAuthChecker = applyAuthChecker;
+exports.applyMiddlewares = applyMiddlewares;
 const auth_middleware_1 = require("../helpers/auth-middleware");
 const types_1 = require("../helpers/types");
 const isPromiseLike_1 = require("../utils/isPromiseLike");
@@ -44,13 +46,11 @@ function getParams(params, resolverData, globalValidate, globalValidateFn) {
     }
     return paramValues;
 }
-exports.getParams = getParams;
 function applyAuthChecker(middlewares, authChecker, container, authMode, roles) {
     if (authChecker && roles) {
         middlewares.unshift((0, auth_middleware_1.AuthMiddleware)(authChecker, container, authMode, roles));
     }
 }
-exports.applyAuthChecker = applyAuthChecker;
 function applyMiddlewares(container, resolverData, middlewares, resolverHandlerFunction) {
     if (middlewares.length === 0) {
         return resolverHandlerFunction();
@@ -84,4 +84,3 @@ function applyMiddlewares(container, resolverData, middlewares, resolverHandlerF
     }
     return dispatchHandler(0);
 }
-exports.applyMiddlewares = applyMiddlewares;

package/build/cjs/resolvers/validate-arg.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateArg = void 0;
+exports.validateArg = validateArg;
 const errors_1 = require("../errors");
 const shouldArgBeValidated = (argValue) => argValue !== null && typeof argValue === "object";
 async function validateArg(argValue, argType, resolverData, globalValidateSettings, argValidateSettings, globalValidateFn, argValidateFn) {
@@ -62,4 +62,3 @@ async function validateArg(argValue, argType, resolverData, globalValidateSettin
         throw new errors_1.ArgumentValidationError(err);
     }
 }
-exports.validateArg = validateArg;

package/build/cjs/schema/definition-node.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInterfaceTypeDefinitionNode = exports.getInputValueDefinitionNode = exports.getFieldDefinitionNode = exports.getInputObjectTypeDefinitionNode = exports.getObjectTypeDefinitionNode = exports.getDirectiveNode = void 0;
+exports.getDirectiveNode = getDirectiveNode;
+exports.getObjectTypeDefinitionNode = getObjectTypeDefinitionNode;
+exports.getInputObjectTypeDefinitionNode = getInputObjectTypeDefinitionNode;
+exports.getFieldDefinitionNode = getFieldDefinitionNode;
+exports.getInputValueDefinitionNode = getInputValueDefinitionNode;
+exports.getInterfaceTypeDefinitionNode = getInterfaceTypeDefinitionNode;
 const graphql_1 = require("graphql");
 const errors_1 = require("../errors");
 function getDirectiveNode(directive) {
@@ -43,7 +48,6 @@ function getDirectiveNode(directive) {
     }
     return directives[0];
 }
-exports.getDirectiveNode = getDirectiveNode;
 function getObjectTypeDefinitionNode(name, directiveMetadata) {
     if (!directiveMetadata || !directiveMetadata.length) {
         return undefined;
@@ -57,7 +61,6 @@ function getObjectTypeDefinitionNode(name, directiveMetadata) {
         directives: directiveMetadata.map(getDirectiveNode),
     };
 }
-exports.getObjectTypeDefinitionNode = getObjectTypeDefinitionNode;
 function getInputObjectTypeDefinitionNode(name, directiveMetadata) {
     if (!directiveMetadata || !directiveMetadata.length) {
         return undefined;
@@ -71,7 +74,6 @@ function getInputObjectTypeDefinitionNode(name, directiveMetadata) {
         directives: directiveMetadata.map(getDirectiveNode),
     };
 }
-exports.getInputObjectTypeDefinitionNode = getInputObjectTypeDefinitionNode;
 function getFieldDefinitionNode(name, type, directiveMetadata) {
     if (!directiveMetadata || !directiveMetadata.length) {
         return undefined;
@@ -92,7 +94,6 @@ function getFieldDefinitionNode(name, type, directiveMetadata) {
         directives: directiveMetadata.map(getDirectiveNode),
     };
 }
-exports.getFieldDefinitionNode = getFieldDefinitionNode;
 function getInputValueDefinitionNode(name, type, directiveMetadata) {
     if (!directiveMetadata || !directiveMetadata.length) {
         return undefined;
@@ -113,7 +114,6 @@ function getInputValueDefinitionNode(name, type, directiveMetadata) {
         directives: directiveMetadata.map(getDirectiveNode),
     };
 }
-exports.getInputValueDefinitionNode = getInputValueDefinitionNode;
 function getInterfaceTypeDefinitionNode(name, directiveMetadata) {
     if (!directiveMetadata || !directiveMetadata.length) {
         return undefined;
@@ -127,4 +127,3 @@ function getInterfaceTypeDefinitionNode(name, directiveMetadata) {
         directives: directiveMetadata.map(getDirectiveNode),
     };
 }
-exports.getInterfaceTypeDefinitionNode = getInterfaceTypeDefinitionNode;