@nestjs/graphql/dist/services/resolvers-explorer.service.d.ts

Nest - modern, fast, powerful node.js web framework (@graphql)

import { MetadataScanner, ModuleRef, ModulesContainer } from '@nestjs/core';
import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-creator.js';
import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper.js';
import { Module } from '@nestjs/core/injector/module.js';
import { SerializedGraph } from '@nestjs/core/inspector/serialized-graph.js';
import { SubscriptionOptions } from '../decorators/subscription.decorator.js';
import { AbstractGraphQLDriver } from '../drivers/abstract-graphql.driver.js';
import { GqlModuleOptions } from '../interfaces/index.js';
import { ResolverMetadata } from '../interfaces/resolver-metadata.interface.js';
import { BaseExplorerService } from './base-explorer.service.js';
import { ResolverDecoratorHost } from './resolver-decorator-host.js';
export declare class ResolversExplorerService extends BaseExplorerService {
    private readonly modulesContainer;
    private readonly metadataScanner;
    private readonly externalContextCreator;
    private readonly gqlOptions;
    private readonly moduleRef;
    private readonly serializedGraph;
    private readonly resolverDecoratorHost;
    private readonly logger;
    private readonly gqlParamsFactory;
    private readonly injector;
    private coreModuleRef;
    private fieldResolverEnhancersLookup;
    private hasGlobalFieldMiddleware;
    constructor(modulesContainer: ModulesContainer, metadataScanner: MetadataScanner, externalContextCreator: ExternalContextCreator, gqlOptions: GqlModuleOptions, moduleRef: ModuleRef, serializedGraph: SerializedGraph, resolverDecoratorHost: ResolverDecoratorHost);
    explore(): Record<string, Record<string, Function | Record<string, any>>>;
    filterResolvers(gqlAdapter: AbstractGraphQLDriver, wrapper: InstanceWrapper, moduleRef: Module): ResolverMetadata[];
    createContextCallback<T extends Record<string, any>>(instance: T, prototype: any, wrapper: InstanceWrapper, moduleRef: Module, resolver: ResolverMetadata, isRequestScoped: boolean, transform?: Function): any;
    /**
     * Rewrites the incoming arguments object onto the property names declared by
     * the `@ArgsType()`/`@InputType()` classes of the method before the resolver
     * context (and therefore any pipe, global ones included) runs.
     */
    private withMappedArgs;
    createSubscriptionMetadata(gqlAdapter: AbstractGraphQLDriver, createSubscribeContext: Function, subscriptionOptions: SubscriptionOptions, resolverMetadata: ResolverMetadata, instanceRef: Record<string, any>): {
        callback: {
            subscribe: any;
            resolve: any;
        };
        name: string;
        type: string;
        methodName: string;
    };
    getAllCtors(): Function[];
    private mapToCtor;
    private registerContextProvider;
    private registerFieldMiddlewareIfExists;
    private getContextId;
    /**
     * 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
     */
    private canUseFastFieldResolver;
    private assignResolverConstructorUniqueId;
}
//# sourceMappingURL=resolvers-explorer.service.d.ts.map