fun generate()

in graphql-dgs-codegen-core/src/main/kotlin/com/netflix/graphql/dgs/codegen/generators/java/DataTypeGenerator.kt [73:169]
87 lines of code
4 McCabe index (conditional complexity)

    fun generate(
        definition: ObjectTypeDefinition,
        extensions: List<ObjectTypeExtensionDefinition>,
    ): CodeGenResult {
        if (definition.shouldSkip(config)) {
            return CodeGenResult.EMPTY
        }

        logger.info("Generating data type {}", definition.name)

        val name = definition.name
        val unionTypes =
            document
                .getDefinitionsOfType(UnionTypeDefinition::class.java)
                .asSequence()
                .filter { union ->
                    union.memberTypes
                        .asSequence()
                        .map { it as TypeName }
                        .any { it.name == name }
                }.map { it.name }
                .toList()

        var implements =
            (definition.implements + extensions.flatMap { it.implements })
                .asSequence()
                .filterIsInstance<TypeName>()
                .map { typeUtils.findReturnType(it).toString() }
                .toList()

        var useInterfaceType = false
        var overrideGetter = false
        var interfaceCodeGenResult = CodeGenResult.EMPTY

        if (config.generateInterfaces) {
            useInterfaceType = true
            val fieldsFromSuperTypes =
                document
                    .getDefinitionsOfType(InterfaceTypeDefinition::class.java)
                    .asSequence()
                    .filter { ClassName.get(packageName, it.name).toString() in implements }
                    .flatMap { it.fieldDefinitions }
                    .map { it.name }

            overrideGetter = true
            val fieldDefinitions =
                definition.fieldDefinitions
                    .asSequence()
                    .filterSkipped()
                    .filter { it.name !in fieldsFromSuperTypes }
                    .map {
                        Field(it.name, typeUtils.findReturnType(it.type, useInterfaceType, true))
                    }.plus(
                        extensions
                            .asSequence()
                            .flatMap { it.fieldDefinitions }
                            .filterSkipped()
                            .map { Field(it.name, typeUtils.findReturnType(it.type, useInterfaceType, true)) },
                    ).toList()

            val interfaceName = "I$name"
            implements = listOf(interfaceName) + implements
            val superInterfaces = definition.implements + extensions.flatMap { it.implements }
            interfaceCodeGenResult = generateInterface(interfaceName, superInterfaces, fieldDefinitions)
        }

        if (config.generateDataTypes) {
            val fieldDefinitions =
                definition.fieldDefinitions
                    .asSequence()
                    .filterSkipped()
                    .map {
                        Field(
                            it.name,
                            typeUtils.findReturnType(it.type, useInterfaceType, true),
                            overrideGetter = overrideGetter,
                            description = it.description,
                            directives = it.directives,
                        )
                    }.plus(
                        extensions.asSequence().flatMap { it.fieldDefinitions }.filterSkipped().map {
                            Field(
                                it.name,
                                typeUtils.findReturnType(it.type, useInterfaceType, true),
                                overrideGetter = overrideGetter,
                                description = it.description,
                                directives = it.directives,
                            )
                        },
                    ).toList()

            return generate(name, unionTypes + implements, fieldDefinitions, definition.description, definition.directives)
                .merge(interfaceCodeGenResult)
        }

        return interfaceCodeGenResult
    }