feat(codegen): implement input/output functions to generated enums to simplify usage with existing enums

Author: WipeAir

graphql-kotlin-toolkit-codegen/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/generator/EnumGenerator.kt

@@ -3,9 +3,13 @@ package com.auritylab.graphql.kotlin.toolkit.codegen.generator
 import com.auritylab.graphql.kotlin.toolkit.codegen.CodegenOptions
 import com.auritylab.graphql.kotlin.toolkit.codegen.mapper.GeneratedMapper
 import com.auritylab.graphql.kotlin.toolkit.codegen.mapper.KotlinTypeMapper
+import com.auritylab.graphql.kotlin.toolkit.common.directive.DirectiveFacade
 import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.MemberName
 import com.squareup.kotlinpoet.PropertySpec
 import com.squareup.kotlinpoet.TypeSpec
 import graphql.schema.GraphQLEnumType
@@ -40,16 +44,105 @@ internal class EnumGenerator(
                     .initializer("stringValue")
                     .build()
             )
-            .also {
+            .also { builder ->
                 // Go through all enum values and create enum constants within this enum.
                 enum.values.forEach { enum ->
-                    it.addEnumConstant(
+                    builder.addEnumConstant(
                         enum.name, TypeSpec.anonymousClassBuilder()
                             .addSuperclassConstructorParameter("%S", enum.name)
                             .build()
                     )
                 }
+
+                // If the "kRepresentation" directive is set on the enum, we have to add a parser/converter function
+                DirectiveFacade.representation.getArguments(enum)?.className
+                    ?.let {
+                        // Add the output property/function.
+                        builder.addProperty(buildParserProperty(it))
+                        builder.addFunction(buildPropertyOperatorFunction())
+
+                        // Add the input functions within a companion, as they are static.
+                        builder.addType(
+                            TypeSpec.companionObjectBuilder()
+                                .addFunction(buildInputParser(it))
+                                .addFunction(buildInputParserOperatorFunction(it))
+                                .build()
+                        )
+                    }
             }
             .build()
     }
+
+    /**
+     * Will build a parser property which is capable of converting the enum constant into the given
+     * [representationClass]. The function utilizes the `.valueOf(...)` method on the enum constant.
+     */
+    private fun buildParserProperty(representationClass: String): PropertySpec {
+        // Resolve the class name and the valueOf function of the class.
+        val parsedClass = ClassName.bestGuess(representationClass)
+
+        // Build the converter code.
+        val code = CodeBlock.builder()
+            .beginControlFlow("return try")
+            .addStatement("%L(name)", MemberName(parsedClass, "valueOf").canonicalName)
+            .endControlFlow()
+            .beginControlFlow("catch(ex: IllegalArgumentException)")
+            .addStatement(
+                "throw NoSuchElementException(%P)",
+                "Enum value '\$name' could not be found on enum '${parsedClass.canonicalName}'"
+            )
+            .endControlFlow()
+            .build()
+
+        return PropertySpec.builder("representation", parsedClass)
+            .getter(FunSpec.getterBuilder().addCode(code).build())
+            .build()
+    }
+
+    /**
+     * Will build a function which overrides the invoke operator and delegates to the "representation" property
+     * to resolve the representation.
+     */
+    private fun buildPropertyOperatorFunction(): FunSpec {
+        return FunSpec.builder("invoke")
+            .addModifiers(KModifier.OPERATOR)
+            .addCode("return representation")
+            .build()
+    }
+
+    /**
+     * Will build a function which accepts the representation enum as input and returns the matching generated
+     * enum constant. This also utilizes the #valueOf(...) method of the enum.
+     */
+    private fun buildInputParser(representationClass: String): FunSpec {
+        val code = CodeBlock.builder()
+            .beginControlFlow("return try")
+            .addStatement("valueOf(input.name)")
+            .endControlFlow()
+            .beginControlFlow("catch(ex: IllegalArgumentException)")
+            .addStatement(
+                "throw NoSuchElementException(%P)",
+                "Enum value '\${input.name}' could not be found on enum '\${this::class.java.canonicalName}'"
+            )
+            .endControlFlow()
+            .build()
+
+        // Build the function with the input and the generated code.
+        return FunSpec.builder("of")
+            .addParameter("input", ClassName.bestGuess(representationClass))
+            .addCode(code)
+            .build()
+    }
+
+    /**
+     * Will build a invoke function override, which delegates to the #of(...) function to convert the
+     * representation enum to the generated enum constant.
+     */
+    private fun buildInputParserOperatorFunction(representationClass: String): FunSpec {
+        return FunSpec.builder("invoke")
+            .addModifiers(KModifier.OPERATOR)
+            .addParameter("input", ClassName.bestGuess(representationClass))
+            .addCode("return of(input)")
+            .build()
+    }
 }

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/implementation/RepresentationDirective.kt

@@ -17,7 +17,8 @@ class RepresentationDirective : AbstractDirective("kRepresentation", false),
             .validLocations(
                 Introspection.DirectiveLocation.OBJECT,
                 Introspection.DirectiveLocation.SCALAR,
-                Introspection.DirectiveLocation.INTERFACE
+                Introspection.DirectiveLocation.INTERFACE,
+                Introspection.DirectiveLocation.ENUM
             )
             .argument {
                 it.name("class")