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

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

import { __decorate, __metadata } from "tslib";
import { Injectable } from '@nestjs/common';
import { GraphQLUnionType } from 'graphql';
import { ReturnTypeCannotBeResolvedError } from '../errors/return-type-cannot-be-resolved.error.js';
import { UnionMemberNotObjectTypeError } from '../errors/union-member-not-object-type.error.js';
import { TypeDefinitionsStorage } from '../storages/type-definitions.storage.js';
import { AstDefinitionNodeFactory } from './ast-definition-node.factory.js';
import { ResolveTypeFactory } from './resolve-type.factory.js';
let UnionDefinitionFactory = class UnionDefinitionFactory {
    constructor(resolveTypeFactory, typeDefinitionsStorage, astDefinitionNodeFactory) {
        this.resolveTypeFactory = resolveTypeFactory;
        this.typeDefinitionsStorage = typeDefinitionsStorage;
        this.astDefinitionNodeFactory = astDefinitionNodeFactory;
    }
    create(metadata) {
        const getObjectType = (item) => {
            const definition = this.typeDefinitionsStorage.getObjectTypeByTarget(item);
            if (!definition) {
                throw new UnionMemberNotObjectTypeError(metadata.name, item);
            }
            return definition.type;
        };
        const types = () => metadata.typesFn().map((item) => getObjectType(item));
        return {
            id: metadata.id,
            type: new GraphQLUnionType({
                name: metadata.name,
                description: metadata.description,
                types,
                resolveType: this.createResolveTypeFn(metadata),
                /**
                 * 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.createUnionTypeNode(metadata.name, metadata.directives),
            }),
        };
    }
    createResolveTypeFn(metadata) {
        return metadata.resolveType
            ? this.resolveTypeFactory.getResolveTypeFunction(metadata.resolveType)
            : (instance) => {
                const target = metadata
                    .typesFn()
                    .find((Type) => instance instanceof Type);
                if (!target) {
                    if (Reflect.has(instance, '__typename')) {
                        return instance.__typename;
                    }
                    throw new ReturnTypeCannotBeResolvedError(metadata.name);
                }
                const objectDef = this.typeDefinitionsStorage.getObjectTypeByTarget(target);
                return objectDef.type?.name;
            };
    }
};
UnionDefinitionFactory = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [ResolveTypeFactory,
        TypeDefinitionsStorage,
        AstDefinitionNodeFactory])
], UnionDefinitionFactory);
export { UnionDefinitionFactory };