fun generate()

in graphql-dgs-codegen-core/src/main/kotlin/com/netflix/graphql/dgs/codegen/generators/kotlin/KotlinInterfaceTypeGenerator.kt [42:112]
59 lines of code
8 McCabe index (conditional complexity)

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

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

        val interfaceBuilder =
            TypeSpec
                .interfaceBuilder(definition.name)
                .addOptionalGeneratedAnnotation(config)
        if (definition.description != null) {
            interfaceBuilder.addKdoc("%L", definition.description.sanitizeKdoc())
        }

        superInterfacesNames(definition)
            .forEach {
                interfaceBuilder.addSuperinterface(typeUtils.findKtInterfaceName(it, packageName))
            }

        val mergedFieldDefinitions = definition.fieldDefinitions + extensions.flatMap { it.fieldDefinitions }

        mergedFieldDefinitions.filterSkipped().forEach { field ->
            val returnType = typeUtils.findReturnType(field.type)
            val nullableType = if (typeUtils.isNullable(field.type)) returnType.copy(nullable = true) else returnType
            val propertySpec = PropertySpec.builder(field.name, nullableType)
            if (field.description != null) {
                propertySpec.addKdoc("%L", field.description.sanitizeKdoc())
            }

            if (definition.implements.isNotEmpty()) {
                val superInterfaceFields =
                    document
                        .getDefinitionsOfType(InterfaceTypeDefinition::class.java)
                        .filter {
                            superInterfacesNames(definition).contains(it.name)
                        }.asSequence()
                        .flatMap { it.fieldDefinitions }
                        .map { it.name }
                        .toSet()

                if (field.name in superInterfaceFields) {
                    propertySpec.addModifiers(KModifier.OVERRIDE)
                }
            }

            interfaceBuilder.addProperty(propertySpec.build())
        }

        val implementations =
            document
                .getDefinitionsOfType(ObjectTypeDefinition::class.java)
                .asSequence()
                .filter { node -> node.implements.any { it.isEqualTo(TypeName(definition.name)) } }
                .map { node -> typeUtils.findKtInterfaceName(node.name, packageName) }
                .filterIsInstance<ClassName>()
                .toList()

        if (implementations.isNotEmpty()) {
            interfaceBuilder.addAnnotation(jsonTypeInfoAnnotation())
            interfaceBuilder.addAnnotation(jsonSubTypesAnnotation(implementations))
        }

        interfaceBuilder.addType(TypeSpec.companionObjectBuilder().addOptionalGeneratedAnnotation(config).build())

        val fileSpec = FileSpec.get(packageName, interfaceBuilder.build())
        return CodeGenResult(kotlinInterfaces = listOf(fileSpec))
    }