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

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

import { __decorate } from "tslib";
import { Injectable } from '@nestjs/common';
import { isEmpty } from '@nestjs/common/utils/shared.utils.js';
import { head } from 'es-toolkit';
import { Kind, parse, } from 'graphql';
import { DirectiveParsingError } from '../errors/directive-parsing.error.js';
let AstDefinitionNodeFactory = class AstDefinitionNodeFactory {
    /**
     * The implementation of this class has been heavily inspired by the folllowing code:
     * @ref https://github.com/MichalLytek/type-graphql/blob/master/src/schema/definition-node.ts
     * implemented in this PR https://github.com/MichalLytek/type-graphql/pull/369 by Jordan Stous (https://github.com/j)
     */
    createObjectTypeNode(name, directiveMetadata) {
        if (isEmpty(directiveMetadata)) {
            return;
        }
        return {
            kind: Kind.OBJECT_TYPE_DEFINITION,
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directiveMetadata.map(this.createDirectiveNode),
        };
    }
    createInputObjectTypeNode(name, directiveMetadata) {
        if (isEmpty(directiveMetadata)) {
            return;
        }
        return {
            kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directiveMetadata.map(this.createDirectiveNode),
        };
    }
    createInterfaceTypeNode(name, directiveMetadata) {
        if (isEmpty(directiveMetadata)) {
            return;
        }
        return {
            kind: Kind.INTERFACE_TYPE_DEFINITION,
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directiveMetadata.map(this.createDirectiveNode),
        };
    }
    createFieldNode(name, type, directiveMetadata) {
        if (isEmpty(directiveMetadata)) {
            return;
        }
        return {
            kind: Kind.FIELD_DEFINITION,
            type: {
                kind: Kind.NAMED_TYPE,
                name: {
                    kind: Kind.NAME,
                    value: type.toString(),
                },
            },
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directiveMetadata.map(this.createDirectiveNode),
        };
    }
    createInputValueNode(name, type, directiveMetadata) {
        if (isEmpty(directiveMetadata)) {
            return;
        }
        return {
            kind: Kind.INPUT_VALUE_DEFINITION,
            type: {
                kind: Kind.NAMED_TYPE,
                name: {
                    kind: Kind.NAME,
                    value: type.toString(),
                },
            },
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directiveMetadata.map(this.createDirectiveNode),
        };
    }
    createArgNode(name, type, directiveMetadata) {
        if (isEmpty(directiveMetadata)) {
            return;
        }
        return {
            kind: Kind.INPUT_VALUE_DEFINITION,
            type: {
                kind: Kind.NAMED_TYPE,
                name: {
                    kind: Kind.NAME,
                    value: type.toString(),
                },
            },
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directiveMetadata.map(this.createDirectiveNode),
        };
    }
    createEnumTypeNode(name, directives) {
        if (isEmpty(directives)) {
            return;
        }
        return {
            kind: Kind.ENUM_TYPE_DEFINITION,
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directives.map((sdl) => this.createDirectiveNode({ sdl })),
        };
    }
    createEnumValueNode(name, directives) {
        if (isEmpty(directives)) {
            return;
        }
        return {
            kind: Kind.ENUM_VALUE_DEFINITION,
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directives.map((sdl) => this.createDirectiveNode({ sdl })),
        };
    }
    createUnionTypeNode(name, directives) {
        if (isEmpty(directives)) {
            return;
        }
        return {
            kind: Kind.UNION_TYPE_DEFINITION,
            name: {
                kind: Kind.NAME,
                value: name,
            },
            directives: directives.map((sdl) => this.createDirectiveNode({ sdl })),
        };
    }
    createDirectiveNode(directive) {
        const parsed = parse(`type String ${directive.sdl}`);
        const definitions = parsed.definitions;
        const directives = definitions
            .filter((item) => item.directives && item.directives.length > 0)
            .map(({ directives }) => directives)
            .reduce((acc, item) => [...acc, ...item]);
        if (directives.length !== 1) {
            throw new DirectiveParsingError(directive.sdl);
        }
        return head(directives);
    }
};
AstDefinitionNodeFactory = __decorate([
    Injectable()
], AstDefinitionNodeFactory);
export { AstDefinitionNodeFactory };