@nestjs/graphql/dist/schema-builder/storages/resolver-implementation.map.d.ts

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

import { BaseResolverMetadata, FieldResolverMetadata, ResolverClassMetadata, ResolverTypeMetadata } from '../metadata';
/**
 * Resolves which resolver class implements the handlers declared on a base class.
 *
 * A handler is recorded against the class it is declared on, but Nest instantiates the class
 * registered as a provider. When a resolver extends a base class, every handler declared on that
 * base therefore has to be reassigned to the derived class:
 *
 *   class BaseUserResolver { @Query(() => User) user() {} }    // target: BaseUserResolver
 *   @Resolver() class UserResolver extends BaseUserResolver {} // the class Nest instantiates
 *
 * so `user` has to end up targeting `UserResolver`. Note that the base class need not be a resolver
 * itself - `@Query` records whichever class the method is written on, decorated or not.
 */
export declare class ResolverImplementationMap {
    private readonly handlerGroups;
    private readonly resolverByBaseClass;
    private readonly logger;
    /**
     * @param resolvers every registered resolver class, in registration order.
     * @param handlerGroups the handler arrays, kept as groups rather than a flattened set so they are
     * only scanned when an ambiguity actually has to be reported.
     */
    constructor(resolvers: readonly ResolverClassMetadata[], handlerGroups: readonly BaseResolverMetadata[][]);
    /** True when no resolver extends anything, so there is nothing to reassign. */
    get isEmpty(): boolean;
    /**
     * The resolver that ends up serving handlers declared on `baseClass`, following the full chain.
     * `resolverByBaseClass` is keyed by base class and holds the resolver extending it, so a lookup
     * steps one level *down* the chain. Keep stepping until nothing extends the class just landed on.
     * Adding `class AdminUserResolver extends UserResolver` to the example above:
     *
     *   BaseUserResolver -> UserResolver -> AdminUserResolver
     *
     * and `AdminUserResolver` serves it. Intermediate classes are stepped through, not selected.
     */
    getResolverImplementationForBaseClass(baseClass: Function): ResolverClassMetadata;
    /** Rewrites every metadata entry to target the resolver class that implements it, if any. */
    collectAllMetadata(baseMetadatas: ResolverTypeMetadata[]): ResolverTypeMetadata[];
    /**
     * Rewrites every field resolver metadata entry to target the resolver class that implements it,
     * if any. A field resolver whose own `objectTypeFn` cannot resolve its host type falls back to
     * the `typeFn` of the resolver that now owns it.
     */
    collectFieldResolversMetadata(fieldResolvers: FieldResolverMetadata[]): FieldResolverMetadata[];
    /** The same handler, reattributed to the resolver class that implements it. */
    private getImplementationMetadataForBaseClass;
    /** Maps every base class to the resolver that inherits its handlers. First registration wins. */
    private collectExtendedResolversMap;
    /**
     * Reached only when a base class is claimed twice. When both resolvers sit on one inheritance
     * chain that is expected, and following the chain attributes the handlers correctly. When they
     * sit on different branches only one can inherit the base, so the other silently misses out -
     * worth reporting, but only if the base declares anything to miss out on.
     */
    private warnOnAmbiguousBaseClass;
    /** True when the class declares at least one handler, i.e. there is something to miss out on. */
    private declaresHandler;
    /** True when either class derives from the other, i.e. they sit on a single inheritance chain. */
    private sharesInheritanceChain;
    private isDerivedFrom;
}
//# sourceMappingURL=resolver-implementation.map.d.ts.map