@nestjs/graphql/dist/schema-builder/type-definitions.generator.js

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

import { __decorate, __metadata } from "tslib";
import { Injectable } from '@nestjs/common';
import { EnumDefinitionFactory } from './factories/enum-definition.factory.js';
import { InputTypeDefinitionFactory } from './factories/input-type-definition.factory.js';
import { InterfaceDefinitionFactory } from './factories/interface-definition.factory.js';
import { ObjectTypeDefinitionFactory } from './factories/object-type-definition.factory.js';
import { UnionDefinitionFactory } from './factories/union-definition.factory.js';
import { TypeDefinitionsStorage } from './storages/type-definitions.storage.js';
import { TypeMetadataStorage } from './storages/type-metadata.storage.js';
let TypeDefinitionsGenerator = class TypeDefinitionsGenerator {
    constructor(typeDefinitionsStorage, enumDefinitionFactory, inputTypeDefinitionFactory, objectTypeDefinitionFactory, interfaceDefinitionFactory, unionDefinitionFactory) {
        this.typeDefinitionsStorage = typeDefinitionsStorage;
        this.enumDefinitionFactory = enumDefinitionFactory;
        this.inputTypeDefinitionFactory = inputTypeDefinitionFactory;
        this.objectTypeDefinitionFactory = objectTypeDefinitionFactory;
        this.interfaceDefinitionFactory = interfaceDefinitionFactory;
        this.unionDefinitionFactory = unionDefinitionFactory;
    }
    generate(options, includeModules) {
        // Clear previous type definitions to support multiple schema generation
        this.typeDefinitionsStorage.clear();
        if (includeModules?.length) {
            // Filter metadata by modules
            this.generateUnionDefs(TypeMetadataStorage.getUnionsMetadataByModules(includeModules));
            this.generateEnumDefs(TypeMetadataStorage.getEnumsMetadataByModules(includeModules));
            this.generateInterfaceDefs(options, TypeMetadataStorage.getInterfacesMetadataByModules(includeModules));
            this.generateObjectTypeDefs(options, TypeMetadataStorage.getObjectTypesMetadataByModules(includeModules));
            this.generateInputTypeDefs(options, TypeMetadataStorage.getInputTypesMetadataByModules(includeModules));
        }
        else {
            // Use all metadata when no module filter is specified
            this.generateUnionDefs();
            this.generateEnumDefs();
            this.generateInterfaceDefs(options);
            this.generateObjectTypeDefs(options);
            this.generateInputTypeDefs(options);
        }
    }
    generateInputTypeDefs(options, metadata) {
        const inputTypeMetadata = metadata ?? TypeMetadataStorage.getInputTypesMetadata();
        const inputTypeDefs = inputTypeMetadata.map((item) => this.inputTypeDefinitionFactory.create(item, options));
        this.typeDefinitionsStorage.addInputTypes(inputTypeDefs);
    }
    generateObjectTypeDefs(options, metadata) {
        const objectTypeMetadata = metadata ?? TypeMetadataStorage.getObjectTypesMetadata();
        const objectTypeDefs = objectTypeMetadata.map((item) => this.objectTypeDefinitionFactory.create(item, options));
        this.typeDefinitionsStorage.addObjectTypes(objectTypeDefs);
    }
    generateInterfaceDefs(options, metadata) {
        const interfaceMetadata = metadata ?? TypeMetadataStorage.getInterfacesMetadata();
        const interfaceDefs = interfaceMetadata.map((item) => this.interfaceDefinitionFactory.create(item, options));
        this.typeDefinitionsStorage.addInterfaces(interfaceDefs);
    }
    generateEnumDefs(metadata) {
        const enumMetadata = metadata ?? TypeMetadataStorage.getEnumsMetadata();
        const enumDefs = enumMetadata.map((item) => this.enumDefinitionFactory.create(item));
        this.typeDefinitionsStorage.addEnums(enumDefs);
    }
    generateUnionDefs(metadata) {
        const unionMetadata = metadata ?? TypeMetadataStorage.getUnionsMetadata();
        const unionDefs = unionMetadata.map((item) => this.unionDefinitionFactory.create(item));
        this.typeDefinitionsStorage.addUnions(unionDefs);
    }
};
TypeDefinitionsGenerator = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [TypeDefinitionsStorage,
        EnumDefinitionFactory,
        InputTypeDefinitionFactory,
        ObjectTypeDefinitionFactory,
        InterfaceDefinitionFactory,
        UnionDefinitionFactory])
], TypeDefinitionsGenerator);
export { TypeDefinitionsGenerator };