@nestjs/graphql/dist/decorators/resolver.decorator.js

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

import { SetMetadata } from '@nestjs/common';
import { ENTRY_PROVIDER_WATERMARK } from '@nestjs/common/constants.js';
import { isFunction, isString } from '@nestjs/common/utils/shared.utils.js';
import 'reflect-metadata';
import { LazyMetadataStorage } from '../schema-builder/storages/lazy-metadata.storage.js';
import { TypeMetadataStorage } from '../schema-builder/storages/type-metadata.storage.js';
import { addResolverMetadata, getClassName, getClassOrUndefined, getResolverTypeFn, } from './resolvers.utils.js';
/**
 * Extracts the name property set through the @ObjectType() decorator (if specified)
 * @param nameOrType type reference
 *
 * @publicApi
 */
function getObjectOrInterfaceTypeNameIfExists(nameOrType) {
    const ctor = getClassOrUndefined(nameOrType);
    const objectMetadata = TypeMetadataStorage.getObjectTypeMetadataByTarget(ctor);
    if (!objectMetadata) {
        const interfaceMetadata = TypeMetadataStorage.getInterfaceMetadataByTarget(ctor);
        if (!interfaceMetadata) {
            return;
        }
        return interfaceMetadata.name;
    }
    return objectMetadata.name;
}
/**
 * Object resolver decorator.
 *
 * @publicApi
 */
export function Resolver(nameOrTypeOrOptions, options) {
    return (target, key, descriptor) => {
        if (typeof target === 'function') {
            SetMetadata(ENTRY_PROVIDER_WATERMARK, true)(target);
        }
        const [nameOrType, resolverOptions] = typeof nameOrTypeOrOptions === 'object' && nameOrTypeOrOptions !== null
            ? [undefined, nameOrTypeOrOptions]
            : [nameOrTypeOrOptions, options];
        let name = nameOrType && getClassName(nameOrType);
        if (isFunction(nameOrType)) {
            const objectName = getObjectOrInterfaceTypeNameIfExists(nameOrType);
            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
            objectName && (name = objectName);
        }
        addResolverMetadata(undefined, name, target, key, descriptor);
        if (!isString(nameOrType)) {
            LazyMetadataStorage.store(target, () => {
                const typeFn = getResolverTypeFn(nameOrType, target);
                TypeMetadataStorage.addResolverMetadata({
                    target: target,
                    typeFn: typeFn,
                    isAbstract: (resolverOptions && resolverOptions.isAbstract) || false,
                });
            });
        }
    };
}