type-graphql 2.0.0-rc.1 → 2.0.0-rc.3

package/build/cjs/helpers/resolver-metadata.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResolverMetadata = void 0;
+exports.getResolverMetadata = getResolverMetadata;
 const errors_1 = require("../errors");
 const findType_1 = require("./findType");
 function getResolverMetadata(prototype, propertyKey, returnTypeFunc, options = {}) {
@@ -26,4 +26,3 @@ function getResolverMetadata(prototype, propertyKey, returnTypeFunc, options = {
         complexity: options.complexity,
     };
 }
-exports.getResolverMetadata = getResolverMetadata;

package/build/cjs/helpers/types.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnumValuesMap = exports.convertToType = exports.wrapWithTypeOptions = exports.convertTypeIfScalar = void 0;
+exports.convertTypeIfScalar = convertTypeIfScalar;
+exports.wrapWithTypeOptions = wrapWithTypeOptions;
+exports.convertToType = convertToType;
+exports.getEnumValuesMap = getEnumValuesMap;
 const graphql_1 = require("graphql");
 const errors_1 = require("../errors");
 const scalars_1 = require("../scalars");
@@ -33,7 +36,6 @@ function convertTypeIfScalar(type) {
             return undefined;
     }
 }
-exports.convertTypeIfScalar = convertTypeIfScalar;
 function wrapWithTypeOptions(target, propertyName, type, typeOptions, nullableByDefault) {
     if (!typeOptions.array &&
         (typeOptions.nullable === "items" || typeOptions.nullable === "itemsAndList")) {
@@ -53,7 +55,6 @@ function wrapWithTypeOptions(target, propertyName, type, typeOptions, nullableBy
     }
     return gqlType;
 }
-exports.wrapWithTypeOptions = wrapWithTypeOptions;
 const simpleTypes = [String, Boolean, Number, Date, Array, Promise];
 function convertToType(Target, data) {
     if (data == null) {
@@ -71,9 +72,14 @@ function convertToType(Target, data) {
     if (Array.isArray(data)) {
         return data.map(item => convertToType(Target, item));
     }
-    return Object.assign(new Target(), data);
+    const instance = new Target();
+    for (const key of Object.keys(instance)) {
+        if (instance[key] === undefined && !(key in data)) {
+            delete instance[key];
+        }
+    }
+    return Object.assign(instance, data);
 }
-exports.convertToType = convertToType;
 function getEnumValuesMap(enumObject) {
     const enumKeys = Object.keys(enumObject).filter(key => Number.isNaN(parseInt(key, 10)));
     const enumMap = enumKeys.reduce((map, key) => {
@@ -82,4 +88,3 @@ function getEnumValuesMap(enumObject) {
     }, {});
     return enumMap;
 }
-exports.getEnumValuesMap = getEnumValuesMap;

package/build/cjs/metadata/getMetadataStorage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMetadataStorage = void 0;
+exports.getMetadataStorage = getMetadataStorage;
 const metadata_storage_1 = require("./metadata-storage");
 function getMetadataStorage() {
     if (!global.TypeGraphQLMetadataStorage) {
@@ -8,4 +8,3 @@ function getMetadataStorage() {
     }
     return global.TypeGraphQLMetadataStorage;
 }
-exports.getMetadataStorage = getMetadataStorage;

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

@@ -10,21 +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);
@@ -53,6 +66,9 @@ class MetadataStorage {
     collectAuthorizedFieldMetadata(definition) {
         this.authorizedFields.push(definition);
     }
+    collectAuthorizedResolverMetadata(definition) {
+        this.authorizedResolver.push(definition);
+    }
     collectEnumMetadata(definition) {
         this.enums.push(definition);
     }
@@ -67,6 +83,9 @@ class MetadataStorage {
     collectMiddlewareMetadata(definition) {
         this.middlewares.push(definition);
     }
+    collectResolverMiddlewareMetadata(definition) {
+        this.resolverMiddlewares.push(definition);
+    }
     collectResolverClassMetadata(definition) {
         this.resolverClasses.push(definition);
     }
@@ -91,12 +110,126 @@ class MetadataStorage {
     collectExtensionsFieldMetadata(definition) {
         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 => {
+                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);
@@ -117,14 +250,27 @@ class MetadataStorage {
         this.argumentTypes = [];
         this.interfaceTypes = [];
         this.authorizedFields = [];
+        this.authorizedResolver = [];
         this.enums = [];
         this.unions = [];
         this.middlewares = [];
+        this.resolverMiddlewares = [];
         this.classDirectives = [];
         this.fieldDirectives = [];
         this.argumentDirectives = [];
         this.classExtensions = [];
         this.fieldExtensions = [];
+        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();
         this.resolverClasses = [];
         this.fields = [];
         this.params = [];
@@ -132,22 +278,25 @@ class MetadataStorage {
     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.middlewares = (0, utils_1.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);
+                    field.params = this.paramsCache.get(field.target)?.get(field.name) || [];
+                    field.middlewares = [
+                        ...(0, utils_1.mapMiddlewareMetadataToArray)([
+                            ...(this.resolverMiddlewaresByTargetCache.get(field.target) || []),
+                        ]),
+                        ...(0, utils_1.mapMiddlewareMetadataToArray)([
+                            ...(this.middlewaresByTargetAndFieldCache.get(field.target)?.get(field.name) || []),
+                        ]),
+                    ];
+                    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);
@@ -156,14 +305,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.middlewares.filter(middleware => middleware.target === def.target && def.methodName === middleware.fieldName));
-            def.directives = this.fieldDirectives
-                .filter(it => it.target === def.target && it.fieldName === def.methodName)
-                .map(it => it.directive);
+            def.middlewares = [
+                ...(0, utils_1.mapMiddlewareMetadataToArray)([
+                    ...(this.resolverMiddlewaresByTargetCache.get(def.target) || []),
+                ]),
+                ...(0, utils_1.mapMiddlewareMetadataToArray)([
+                    ...(this.middlewaresByTargetAndFieldCache.get(def.target)?.get(def.methodName) || []),
+                ]),
+            ];
+            def.directives = (this.fieldDirectivesByTargetAndFieldCache.get(def.target)?.get(def.methodName) || []).map(it => it.directive);
             def.extensions = this.findExtensions(def.target, def.methodName);
         });
     }
@@ -171,19 +324,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}'`);
                 }
@@ -234,7 +383,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);
@@ -246,7 +395,8 @@ class MetadataStorage {
         });
     }
     findFieldRoles(target, fieldName) {
-        const authorizedField = this.authorizedFields.find(authField => authField.target === target && authField.fieldName === fieldName);
+        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");
@@ -32,6 +34,10 @@ function getParams(params, resolverData, globalValidate, globalValidateFn) {
             case "info":
                 return resolverData.info;
             case "custom":
+                if (paramInfo.options.arg) {
+                    const arg = paramInfo.options.arg;
+                    return (0, validate_arg_1.validateArg)((0, convert_args_1.convertArgToInstance)(arg, resolverData.args), arg.getType(), resolverData, globalValidate, arg.validateSettings, globalValidateFn, arg.validateFn).then(() => paramInfo.resolver(resolverData));
+                }
                 return paramInfo.resolver(resolverData);
         }
     });
@@ -40,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();
@@ -80,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;