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

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TypeDefinitionsGenerator = void 0;
const tslib_1 = require("tslib");
const common_1 = require("@nestjs/common");
const enum_definition_factory_1 = require("./factories/enum-definition.factory");
const input_type_definition_factory_1 = require("./factories/input-type-definition.factory");
const interface_definition_factory_1 = require("./factories/interface-definition.factory");
const object_type_definition_factory_1 = require("./factories/object-type-definition.factory");
const union_definition_factory_1 = require("./factories/union-definition.factory");
const type_definitions_storage_1 = require("./storages/type-definitions.storage");
const type_metadata_storage_1 = require("./storages/type-metadata.storage");
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(type_metadata_storage_1.TypeMetadataStorage.getUnionsMetadataByModules(includeModules));
            this.generateEnumDefs(type_metadata_storage_1.TypeMetadataStorage.getEnumsMetadataByModules(includeModules));
            this.generateInterfaceDefs(options, type_metadata_storage_1.TypeMetadataStorage.getInterfacesMetadataByModules(includeModules));
            this.generateObjectTypeDefs(options, type_metadata_storage_1.TypeMetadataStorage.getObjectTypesMetadataByModules(includeModules));
            this.generateInputTypeDefs(options, type_metadata_storage_1.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 ?? type_metadata_storage_1.TypeMetadataStorage.getInputTypesMetadata();
        const inputTypeDefs = inputTypeMetadata.map((item) => this.inputTypeDefinitionFactory.create(item, options));
        this.typeDefinitionsStorage.addInputTypes(inputTypeDefs);
    }
    generateObjectTypeDefs(options, metadata) {
        const objectTypeMetadata = metadata ?? type_metadata_storage_1.TypeMetadataStorage.getObjectTypesMetadata();
        const objectTypeDefs = objectTypeMetadata.map((item) => this.objectTypeDefinitionFactory.create(item, options));
        this.typeDefinitionsStorage.addObjectTypes(objectTypeDefs);
    }
    generateInterfaceDefs(options, metadata) {
        const interfaceMetadata = metadata ?? type_metadata_storage_1.TypeMetadataStorage.getInterfacesMetadata();
        const interfaceDefs = interfaceMetadata.map((item) => this.interfaceDefinitionFactory.create(item, options));
        this.typeDefinitionsStorage.addInterfaces(interfaceDefs);
    }
    generateEnumDefs(metadata) {
        const enumMetadata = metadata ?? type_metadata_storage_1.TypeMetadataStorage.getEnumsMetadata();
        const enumDefs = enumMetadata.map((item) => this.enumDefinitionFactory.create(item));
        this.typeDefinitionsStorage.addEnums(enumDefs);
    }
    generateUnionDefs(metadata) {
        const unionMetadata = metadata ?? type_metadata_storage_1.TypeMetadataStorage.getUnionsMetadata();
        const unionDefs = unionMetadata.map((item) => this.unionDefinitionFactory.create(item));
        this.typeDefinitionsStorage.addUnions(unionDefs);
    }
};
exports.TypeDefinitionsGenerator = TypeDefinitionsGenerator;
exports.TypeDefinitionsGenerator = TypeDefinitionsGenerator = tslib_1.__decorate([
    (0, common_1.Injectable)(),
    tslib_1.__metadata("design:paramtypes", [type_definitions_storage_1.TypeDefinitionsStorage,
        enum_definition_factory_1.EnumDefinitionFactory,
        input_type_definition_factory_1.InputTypeDefinitionFactory,
        object_type_definition_factory_1.ObjectTypeDefinitionFactory,
        interface_definition_factory_1.InterfaceDefinitionFactory,
        union_definition_factory_1.UnionDefinitionFactory])
], TypeDefinitionsGenerator);