@nestjs/graphql/dist/schema-builder/factories/args.factory.js

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

import { __decorate, __metadata } from "tslib";
import { Injectable } from '@nestjs/common';
import { isUndefined } from '@nestjs/common/utils/shared.utils.js';
import { CannotDetermineArgTypeError } from '../errors/cannot-determine-arg-type.error.js';
import { getDefaultValue } from '../helpers/get-default-value.helper.js';
import { normalizeEnumDefaultValue } from '../helpers/normalize-enum-default-value.helper.js';
import { TypeMetadataStorage } from '../storages/type-metadata.storage.js';
import { InputTypeFactory } from './input-type.factory.js';
import { AstDefinitionNodeFactory } from './ast-definition-node.factory.js';
let ArgsFactory = class ArgsFactory {
    constructor(inputTypeFactory, astDefinitionNodeFactory) {
        this.inputTypeFactory = inputTypeFactory;
        this.astDefinitionNodeFactory = astDefinitionNodeFactory;
    }
    create(args, options) {
        const fieldConfigMap = {};
        args.forEach((param) => {
            if (param.kind === 'arg') {
                const typeRef = param.typeFn();
                fieldConfigMap[param.name] = {
                    description: param.description,
                    deprecationReason: param.deprecationReason,
                    type: this.inputTypeFactory.create(param.name, typeRef, options, param.options),
                    defaultValue: normalizeEnumDefaultValue(param.options.defaultValue, typeRef, TypeMetadataStorage.getEnumsMetadata()),
                };
            }
            else if (param.kind === 'args') {
                const argumentTypes = TypeMetadataStorage.getArgumentsMetadata();
                const hostType = param.typeFn();
                const argumentType = argumentTypes.find((item) => item.target === hostType);
                if (!argumentType) {
                    throw new CannotDetermineArgTypeError(hostType.name || hostType, param);
                }
                let parent = Object.getPrototypeOf(argumentType.target);
                while (!isUndefined(parent.prototype)) {
                    const parentArgType = argumentTypes.find((item) => item.target === parent);
                    if (parentArgType) {
                        this.inheritParentArgs(parentArgType, options, fieldConfigMap);
                    }
                    parent = Object.getPrototypeOf(parent);
                }
                this.inheritParentArgs(argumentType, options, fieldConfigMap);
            }
        });
        return fieldConfigMap;
    }
    inheritParentArgs(argType, options, fieldConfigMap = {}) {
        const argumentInstance = new argType.target();
        argType.properties.forEach((field) => {
            field.options.defaultValue = getDefaultValue(argumentInstance, field.options, field.name, argType.name);
            const { schemaName } = field;
            const typeRef = field.typeFn();
            const type = this.inputTypeFactory.create(field.name, typeRef, options, field.options);
            fieldConfigMap[schemaName] = {
                description: field.description,
                deprecationReason: field.deprecationReason,
                type,
                defaultValue: normalizeEnumDefaultValue(field.options.defaultValue, typeRef, TypeMetadataStorage.getEnumsMetadata()),
                /**
                 * AST node has to be manually created in order to define directives
                 * (more on this topic here: https://github.com/graphql/graphql-js/issues/1343)
                 */
                astNode: this.astDefinitionNodeFactory.createArgNode(field.name, type, field.directives),
            };
        });
    }
};
ArgsFactory = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [InputTypeFactory,
        AstDefinitionNodeFactory])
], ArgsFactory);
export { ArgsFactory };