@nestjs/graphql
Version:
Nest - modern, fast, powerful node.js web framework (@graphql)
260 lines (259 loc) • 13.4 kB
JavaScript
"use strict";
var ResolversExplorerService_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResolversExplorerService = void 0;
const tslib_1 = require("tslib");
const common_1 = require("@nestjs/common");
const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
const core_1 = require("@nestjs/core");
const external_context_creator_1 = require("@nestjs/core/helpers/external-context-creator");
const constants_1 = require("@nestjs/core/injector/constants");
const injector_1 = require("@nestjs/core/injector/injector");
const internal_core_module_1 = require("@nestjs/core/injector/internal-core-module");
const serialized_graph_1 = require("@nestjs/core/inspector/serialized-graph");
const request_constants_1 = require("@nestjs/core/router/request/request-constants");
const lodash_1 = require("lodash");
const abstract_graphql_driver_1 = require("../drivers/abstract-graphql.driver");
const gql_paramtype_enum_1 = require("../enums/gql-paramtype.enum");
const resolver_enum_1 = require("../enums/resolver.enum");
const params_factory_1 = require("../factories/params.factory");
const graphql_constants_1 = require("../graphql.constants");
const decorate_field_resolver_util_1 = require("../utils/decorate-field-resolver.util");
const extract_metadata_util_1 = require("../utils/extract-metadata.util");
const base_explorer_service_1 = require("./base-explorer.service");
const ROOT_RESOLVER_TYPES = new Set([
resolver_enum_1.Resolver.MUTATION,
resolver_enum_1.Resolver.QUERY,
resolver_enum_1.Resolver.SUBSCRIPTION,
]);
let ResolversExplorerService = ResolversExplorerService_1 = class ResolversExplorerService extends base_explorer_service_1.BaseExplorerService {
constructor(modulesContainer, metadataScanner, externalContextCreator, gqlOptions, moduleRef, serializedGraph) {
super();
this.modulesContainer = modulesContainer;
this.metadataScanner = metadataScanner;
this.externalContextCreator = externalContextCreator;
this.gqlOptions = gqlOptions;
this.moduleRef = moduleRef;
this.serializedGraph = serializedGraph;
this.logger = new common_1.Logger(ResolversExplorerService_1.name);
this.gqlParamsFactory = new params_factory_1.GqlParamsFactory();
this.injector = new injector_1.Injector();
this.fieldResolverEnhancersLookup = null;
this.hasGlobalFieldMiddleware = null;
}
explore() {
const modules = this.getModules(this.modulesContainer, this.gqlOptions.include || []);
const gqlAdapter = this.moduleRef.get(abstract_graphql_driver_1.AbstractGraphQLDriver);
const resolvers = this.flatMap(modules, (instance, moduleRef) => this.filterResolvers(gqlAdapter, instance, moduleRef));
return this.groupMetadata(resolvers);
}
filterResolvers(gqlAdapter, wrapper, moduleRef) {
const { instance } = wrapper;
if (!instance) {
return undefined;
}
const prototype = Object.getPrototypeOf(instance);
const predicate = (resolverType, isReferenceResolver, isPropertyResolver) => (0, shared_utils_1.isUndefined)(resolverType) ||
(!isReferenceResolver &&
!isPropertyResolver &&
!ROOT_RESOLVER_TYPES.has(resolverType));
const resolvers = this.metadataScanner
.getAllMethodNames(prototype)
.map((name) => (0, extract_metadata_util_1.extractMetadata)(instance, prototype, name, predicate))
.filter((resolver) => !!resolver);
const isRequestScoped = !wrapper.isDependencyTreeStatic();
return resolvers.map((resolver) => {
this.assignResolverConstructorUniqueId(instance.constructor, moduleRef);
const entrypointDefinition = {
id: `${wrapper.id}_${resolver.methodName}`,
type: 'graphql-entrypoint',
methodName: resolver.methodName,
className: wrapper.name,
classNodeId: wrapper.id,
metadata: {
key: resolver.name,
parentType: resolver.type,
},
};
this.serializedGraph.insertEntrypoint(entrypointDefinition, wrapper.id);
const createContext = (transform) => this.createContextCallback(instance, prototype, wrapper, moduleRef, resolver, isRequestScoped, transform);
if (resolver.type === graphql_constants_1.SUBSCRIPTION_TYPE) {
if (!wrapper.isDependencyTreeStatic()) {
// Note: We don't throw an exception here for backward
// compatibility reasons.
this.logger.error(`"${wrapper.metatype.name}" resolver is request or transient-scoped. Resolvers that register subscriptions with the "@Subscription()" decorator must be static (singleton).`);
}
const subscriptionOptions = Reflect.getMetadata(graphql_constants_1.SUBSCRIPTION_OPTIONS_METADATA, instance[resolver.methodName]);
return this.createSubscriptionMetadata(gqlAdapter, createContext, subscriptionOptions, resolver, instance);
}
return {
...resolver,
callback: createContext(),
};
});
}
createContextCallback(instance, prototype, wrapper, moduleRef, resolver, isRequestScoped, transform = lodash_1.identity) {
const paramsFactory = this.gqlParamsFactory;
const isPropertyResolver = !ROOT_RESOLVER_TYPES.has(resolver.type);
if (this.fieldResolverEnhancersLookup === null) {
const enhancers = this.gqlOptions.fieldResolverEnhancers || [];
this.fieldResolverEnhancersLookup = {
guards: enhancers.includes('guards'),
filters: enhancers.includes('filters'),
interceptors: enhancers.includes('interceptors'),
};
}
const contextOptions = resolver.methodName === graphql_constants_1.FIELD_TYPENAME
? { guards: false, filters: false, interceptors: false }
: isPropertyResolver
? this.fieldResolverEnhancersLookup
: undefined;
if (isRequestScoped) {
const resolverCallback = async (...args) => {
const gqlContext = paramsFactory.exchangeKeyForValue(gql_paramtype_enum_1.GqlParamtype.CONTEXT, undefined, args);
const contextId = this.getContextId(gqlContext);
this.registerContextProvider(gqlContext, contextId);
const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[resolver.methodName]), resolver.methodName, graphql_constants_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, contextOptions, 'graphql');
return callback(...args);
};
return isPropertyResolver
? this.registerFieldMiddlewareIfExists(resolverCallback, instance, resolver.methodName)
: resolverCallback;
}
if (isPropertyResolver &&
this.canUseFastFieldResolver(instance, resolver.methodName, contextOptions)) {
const resolverFn = prototype[resolver.methodName];
if (typeof resolverFn === 'function') {
return resolverFn.bind(instance);
}
}
const resolverCallback = this.externalContextCreator.create(instance, prototype[resolver.methodName], resolver.methodName, graphql_constants_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, contextOptions, 'graphql');
return isPropertyResolver
? this.registerFieldMiddlewareIfExists(resolverCallback, instance, resolver.methodName)
: resolverCallback;
}
createSubscriptionMetadata(gqlAdapter, createSubscribeContext, subscriptionOptions, resolverMetadata, instanceRef) {
const resolveFunc = subscriptionOptions &&
subscriptionOptions.resolve &&
subscriptionOptions.resolve.bind(instanceRef);
const baseCallbackMetadata = {
resolve: resolveFunc,
};
if (subscriptionOptions && subscriptionOptions.filter) {
return {
...resolverMetadata,
callback: {
...baseCallbackMetadata,
subscribe: gqlAdapter.subscriptionWithFilter(instanceRef, subscriptionOptions.filter, createSubscribeContext),
},
};
}
return {
...resolverMetadata,
callback: {
...baseCallbackMetadata,
subscribe: createSubscribeContext(),
},
};
}
getAllCtors() {
const modules = this.getModules(this.modulesContainer, this.gqlOptions.include || []);
const resolvers = this.flatMap(modules, this.mapToCtor).filter(Boolean);
return resolvers;
}
mapToCtor(wrapper) {
const { instance } = wrapper;
if (!instance) {
return undefined;
}
return instance.constructor;
}
registerContextProvider(request, contextId) {
if (this.coreModuleRef === undefined) {
let foundModule = null;
for (const [, moduleRef] of this.modulesContainer.entries()) {
if (moduleRef.metatype?.name === internal_core_module_1.InternalCoreModule.name) {
foundModule = moduleRef;
break;
}
}
this.coreModuleRef = foundModule;
}
if (!this.coreModuleRef) {
return;
}
const wrapper = this.coreModuleRef.getProviderByKey(core_1.REQUEST);
wrapper.setInstanceByContextId(contextId, {
instance: contextId.getParent ? contextId.payload : request,
isResolved: true,
});
}
registerFieldMiddlewareIfExists(resolverFn, instance, methodKey) {
const fieldMiddleware = Reflect.getMetadata(graphql_constants_1.FIELD_RESOLVER_MIDDLEWARE_METADATA, instance[methodKey]);
const middlewareFunctions = (this.gqlOptions?.buildSchemaOptions?.fieldMiddleware || []).concat(fieldMiddleware || []);
if (middlewareFunctions?.length === 0) {
return resolverFn;
}
const originalResolveFnFactory = (...args) => () => resolverFn(...args);
return (0, decorate_field_resolver_util_1.decorateFieldResolverWithMiddleware)(originalResolveFnFactory, middlewareFunctions);
}
getContextId(gqlContext) {
const contextId = core_1.ContextIdFactory.getByRequest(gqlContext, ['req']);
if (!gqlContext[request_constants_1.REQUEST_CONTEXT_ID]) {
Object.defineProperty(gqlContext, request_constants_1.REQUEST_CONTEXT_ID, {
value: contextId,
enumerable: false,
configurable: false,
writable: false,
});
}
return contextId;
}
/**
* Determines if a field resolver can use the fast-path that bypasses
* ExternalContextCreator overhead. This is possible when:
* - No guards/filters/interceptors are enabled for field resolvers
* - No field middleware is registered (global or method-level)
* - No parameter decorators (@Parent, @Args, etc.) are used on the method
*/
canUseFastFieldResolver(instance, methodKey, contextOptions) {
if (contextOptions?.guards ||
contextOptions?.filters ||
contextOptions?.interceptors) {
return false;
}
const fieldMiddleware = Reflect.getMetadata(graphql_constants_1.FIELD_RESOLVER_MIDDLEWARE_METADATA, instance[methodKey]);
if (fieldMiddleware?.length > 0) {
return false;
}
if (this.hasGlobalFieldMiddleware === null) {
const globalMiddleware = this.gqlOptions?.buildSchemaOptions?.fieldMiddleware;
this.hasGlobalFieldMiddleware = (globalMiddleware?.length ?? 0) > 0;
}
if (this.hasGlobalFieldMiddleware) {
return false;
}
const paramMetadata = Reflect.getMetadata(graphql_constants_1.PARAM_ARGS_METADATA, instance.constructor, methodKey);
if (paramMetadata && Object.keys(paramMetadata).length > 0) {
return false;
}
return true;
}
assignResolverConstructorUniqueId(resolverConstructor, moduleRef) {
// eslint-disable-next-line no-prototype-builtins
if (resolverConstructor.hasOwnProperty(constants_1.CONTROLLER_ID_KEY)) {
return;
}
moduleRef.assignControllerUniqueId(resolverConstructor);
}
};
exports.ResolversExplorerService = ResolversExplorerService;
exports.ResolversExplorerService = ResolversExplorerService = ResolversExplorerService_1 = tslib_1.__decorate([
(0, common_1.Injectable)(),
tslib_1.__param(3, (0, common_1.Inject)(graphql_constants_1.GRAPHQL_MODULE_OPTIONS)),
tslib_1.__metadata("design:paramtypes", [core_1.ModulesContainer,
core_1.MetadataScanner,
external_context_creator_1.ExternalContextCreator, Object, core_1.ModuleRef,
serialized_graph_1.SerializedGraph])
], ResolversExplorerService);