feat: generate override directive based on fed version

Author: sjin

examples/client/server/src/main/kotlin/com/expediagroup/graphql/examples/client/server/FederatedQuery.kt

@@ -96,7 +96,7 @@ data class ProductVariation(
 data class User(
     @ExternalDirective
     val email: String,
-    @OverrideDirective(from = "users", label = "Migrating name field")
+    @OverrideDirective(from = "users")
     val name: String,
     @ExternalDirective
     val totalProductsCreated: Int? = null

generator/graphql-kotlin-federation/src/main/kotlin/com/expediagroup/graphql/generator/federation/FederatedSchemaGeneratorHooks.kt

@@ -77,7 +77,6 @@ import graphql.TypeResolutionEnvironment
 import graphql.schema.DataFetcher
 import graphql.schema.FieldCoordinates
 import graphql.schema.GraphQLAppliedDirective
-import graphql.schema.GraphQLAppliedDirectiveArgument
 import graphql.schema.GraphQLCodeRegistry
 import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLDirectiveContainer
@@ -98,8 +97,8 @@ open class FederatedSchemaGeneratorHooks(
     private val resolvers: List<FederatedTypeResolver>
 ) : FlowSubscriptionSchemaGeneratorHooks() {
     private val validator: FederatedSchemaValidator = FederatedSchemaValidator()
-    data class LinkSpec(val namespace: String, val imports: Map<String, String>)
-    private val linkSpecs: MutableMap<String, LinkSpec> = HashMap()
+    data class LinkSpec(val namespace: String, val imports: Map<String, String>, val url: String? = FEDERATION_SPEC_LATEST_URL)
+    public val linkSpecs: MutableMap<String, LinkSpec> = HashMap()
 
     // workaround to https://github.com/ExpediaGroup/graphql-kotlin/issues/1815
     // since those scalars can be renamed, we need to ensure we only generate those scalars just once
@@ -175,7 +174,7 @@ open class FederatedSchemaGeneratorHooks(
                     normalizeImportName(import.name) to normalizeImportName(importedName)
                 }
 
-                val linkSpec = LinkSpec(nameSpace, imports)
+                val linkSpec = LinkSpec(nameSpace, imports, appliedDirectiveAnnotation.url)
                 linkSpecs[spec] = linkSpec
             }
         }
@@ -218,19 +217,23 @@ open class FederatedSchemaGeneratorHooks(
         else -> super.willGenerateGraphQLType(type)
     }
 
-    override fun willGenerateDirective(directiveInfo: DirectiveMetaInformation): GraphQLDirective? =
-        when (directiveInfo.effectiveName) {
+    override fun willGenerateDirective(directiveInfo: DirectiveMetaInformation): GraphQLDirective? {
+        val federationSpec = linkSpecs[FEDERATION_SPEC]
+        val federationUrl = federationSpec?.url ?: FEDERATION_SPEC_LATEST_URL
+
+        return when (directiveInfo.effectiveName) {
             CONTACT_DIRECTIVE_NAME -> CONTACT_DIRECTIVE_TYPE
             EXTERNAL_DIRECTIVE_NAME -> EXTERNAL_DIRECTIVE_TYPE
             KEY_DIRECTIVE_NAME -> keyDirectiveDefinition(fieldSetScalar)
             LINK_DIRECTIVE_NAME -> linkDirectiveDefinition(linkImportScalar)
-            OVERRIDE_DIRECTIVE_NAME -> overrideDirectiveDefinition()
-            POLICY_DIRECTIVE_NAME -> policyDirectiveDefinition(policiesScalar)
+            OVERRIDE_DIRECTIVE_NAME -> overrideDirectiveDefinition(federationUrl)
+            POLICY_DIRECTIVE_NAME -> policyDirectiveDefinition(policiesScalar, federationUrl)
             PROVIDES_DIRECTIVE_NAME -> providesDirectiveDefinition(fieldSetScalar)
             REQUIRES_DIRECTIVE_NAME -> requiresDirectiveDefinition(fieldSetScalar)
             REQUIRES_SCOPE_DIRECTIVE_NAME -> requiresScopesDirectiveType(scopesScalar)
             else -> super.willGenerateDirective(directiveInfo)
         }
+    }
 
     override fun willApplyDirective(directiveInfo: DirectiveMetaInformation, directive: GraphQLDirective): GraphQLAppliedDirective? {
         return when (directiveInfo.effectiveName) {
@@ -300,7 +303,8 @@ open class FederatedSchemaGeneratorHooks(
                 // only add @link directive definition if it doesn't exist yet
                 builder.additionalDirective(linkDirective)
             }
-            builder.withSchemaAppliedDirective(linkDirective.toAppliedLinkDirective(FEDERATION_SPEC_LATEST_URL, null, fed2Imports))
+            val federationUrl = linkSpecs[FEDERATION_SPEC]?.url ?: FEDERATION_SPEC_LATEST_URL
+            builder.withSchemaAppliedDirective(linkDirective.toAppliedLinkDirective(federationUrl, null, fed2Imports))
         }
 
         val federatedCodeRegistry = GraphQLCodeRegistry.newCodeRegistry(originalSchema.codeRegistry)

generator/graphql-kotlin-federation/src/main/kotlin/com/expediagroup/graphql/generator/federation/FederationVersionUtils.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 Expedia, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.expediagroup.graphql.generator.federation
+
+/**
+ * Checks if the federation version from the URL meets or exceeds the specified version.
+ *
+ * @param federationUrl The federation specification URL (e.g., "https://specs.apollo.dev/federation/v2.7")
+ * @param major The major version to check against
+ * @param minor The minor version to check against
+ * @return True if the URL's version is at least the specified major.minor version
+ */
+internal fun isFederationVersionAtLeast(federationUrl: String, major: Int, minor: Int): Boolean {
+    val versionRegex = """.*?/v?(\d+)\.(\d+).*""".toRegex()
+    val matchResult = versionRegex.find(federationUrl)
+
+    return if (matchResult != null) {
+        val (majorStr, minorStr) = matchResult.destructured
+        val fedMajor = majorStr.toIntOrNull() ?: 0
+        val fedMinor = minorStr.toIntOrNull() ?: 0
+
+        fedMajor > major || (fedMajor == major && fedMinor >= minor)
+    } else {
+        false
+    }
+}

generator/graphql-kotlin-federation/src/main/kotlin/com/expediagroup/graphql/generator/federation/directives/OverrideDirective.kt

@@ -18,6 +18,7 @@ package com.expediagroup.graphql.generator.federation.directives
 
 import com.expediagroup.graphql.generator.annotations.GraphQLDirective
 import com.expediagroup.graphql.generator.directives.DirectiveMetaInformation
+import com.expediagroup.graphql.generator.federation.isFederationVersionAtLeast
 import graphql.Scalars
 import graphql.introspection.Introspection.DirectiveLocation
 import graphql.schema.GraphQLAppliedDirective
@@ -56,7 +57,7 @@ private const val OVERRIDE_DIRECTIVE_DESCRIPTION = "Overrides fields resolution
 /**
  * Creates the override directive definition
  */
-internal fun overrideDirectiveDefinition(): graphql.schema.GraphQLDirective {
+internal fun overrideDirectiveDefinition(federationVersion: String = FEDERATION_SPEC_LATEST_URL): graphql.schema.GraphQLDirective {
     val builder = graphql.schema.GraphQLDirective.newDirective()
         .name(OVERRIDE_DIRECTIVE_NAME)
         .description(OVERRIDE_DIRECTIVE_DESCRIPTION)
@@ -66,16 +67,16 @@ internal fun overrideDirectiveDefinition(): graphql.schema.GraphQLDirective {
                 .name(OVERRIDE_DIRECTIVE_FROM_PARAM)
                 .description("Name of the subgraph to override field resolution")
                 .type(GraphQLNonNull(Scalars.GraphQLString))
-                .build()
         )
 
-    builder.argument(
-        GraphQLArgument.newArgument()
-            .name(OVERRIDE_DIRECTIVE_LABEL_PARAM)
-            .description("The value must follow the format of 'percent(number)'")
-            .type(Scalars.GraphQLString)
-            .build()
-    )
+    if (isFederationVersionAtLeast(federationVersion, 2, 7)) {
+        builder.argument(
+            GraphQLArgument.newArgument()
+                .name(OVERRIDE_DIRECTIVE_LABEL_PARAM)
+                .description("The value must follow the format of 'percent(number)'")
+                .type(Scalars.GraphQLString)
+        )
+    }
 
     return builder.build()
 }
@@ -94,18 +95,22 @@ internal fun graphql.schema.GraphQLDirective.toAppliedOverrideDirective(directiv
 
     val builder = GraphQLAppliedDirective.newDirective()
         .name(this.name)
-        .argument(GraphQLAppliedDirectiveArgument.newArgument()
+        .argument(
+            GraphQLAppliedDirectiveArgument.newArgument()
             .name(OVERRIDE_DIRECTIVE_FROM_PARAM)
             .type(GraphQLNonNull(Scalars.GraphQLString))
             .valueProgrammatic(overrideDirective.from)
-            .build())
+            .build()
+        )
 
     if (!label.isNullOrEmpty()) {
-        builder.argument(GraphQLAppliedDirectiveArgument.newArgument()
+        builder.argument(
+            GraphQLAppliedDirectiveArgument.newArgument()
             .name(OVERRIDE_DIRECTIVE_LABEL_PARAM)
             .type(Scalars.GraphQLString)
             .valueProgrammatic(label)
-            .build())
+            .build()
+        )
     }
 
     return builder.build()

generator/graphql-kotlin-federation/src/test/kotlin/com/expediagroup/graphql/generator/federation/directives/override/OverrideDirectiveTest.kt

@@ -20,6 +20,7 @@ import com.expediagroup.graphql.generator.TopLevelObject
 import com.expediagroup.graphql.generator.extensions.print
 import com.expediagroup.graphql.generator.federation.FederatedSchemaGeneratorConfig
 import com.expediagroup.graphql.generator.federation.FederatedSchemaGeneratorHooks
+import com.expediagroup.graphql.generator.federation.directives.FEDERATION_SPEC
 import com.expediagroup.graphql.generator.federation.directives.OVERRIDE_DIRECTIVE_NAME
 import com.expediagroup.graphql.generator.federation.toFederatedSchema
 import com.expediagroup.graphql.generator.federation.directives.OverrideDirective
@@ -30,7 +31,7 @@ import kotlin.test.assertNotNull
 class OverrideDirectiveTest {
 
     @Test
-    fun `verify override directive definition`() {
+    fun `verify override directive definition for fed27`() {
         val expectedSchema =
             """
             schema @link(import : ["@override"], url : "https://specs.apollo.dev/federation/v2.7"){
@@ -59,7 +60,7 @@ class OverrideDirectiveTest {
             directive @override(
                 "Name of the subgraph to override field resolution"
                 from: String!,
-                "The value must follow the format of 'percent(number)'. Enterprise feature available in Federation 2.7+."
+                "The value must follow the format of 'percent(number)'"
                 label: String
               ) on FIELD_DEFINITION
 
@@ -92,7 +93,7 @@ class OverrideDirectiveTest {
             supportedPackages = listOf("com.expediagroup.graphql.generator.federation.directives.override"),
             hooks = FederatedSchemaGeneratorHooks(emptyList())
         )
-        val schema = toFederatedSchema(config, listOf(TopLevelObject(Query())))
+        val schema = toFederatedSchema(config, listOf(TopLevelObject(Fed27Query())))
         Assertions.assertEquals(expectedSchema, schema.print().trim())
 
         val query = schema.getObjectType("Query")
@@ -105,12 +106,92 @@ class OverrideDirectiveTest {
         assertNotNull(barQuery.hasAppliedDirective(OVERRIDE_DIRECTIVE_NAME))
     }
 
+    @Test
+    fun `verify override directive definition for fed20`() {
+        val expectedSchema =
+            """
+            schema @link(import : ["@override"], url : "https://specs.apollo.dev/federation/v2.0"){
+              query: Query
+            }
+
+            "Marks the field, argument, input field or enum value as deprecated"
+            directive @deprecated(
+                "The reason for the deprecation"
+                reason: String = "No longer supported"
+              ) on FIELD_DEFINITION | ARGUMENT_DEFINITION | ENUM_VALUE | INPUT_FIELD_DEFINITION
+
+            "Directs the executor to include this field or fragment only when the `if` argument is true"
+            directive @include(
+                "Included when true."
+                if: Boolean!
+              ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+            "Links definitions within the document to external schemas."
+            directive @link(as: String, import: [link__Import], url: String!) repeatable on SCHEMA
+
+            "Indicates an Input Object is a OneOf Input Object."
+            directive @oneOf on INPUT_OBJECT
+
+            "Overrides fields resolution logic from other subgraph. Used for migrating fields from one subgraph to another."
+            directive @override(
+                "Name of the subgraph to override field resolution"
+                from: String!
+              ) on FIELD_DEFINITION
+
+            "Directs the executor to skip this field or fragment when the `if` argument is true."
+            directive @skip(
+                "Skipped when true."
+                if: Boolean!
+              ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+            "Exposes a URL that specifies the behaviour of this scalar."
+            directive @specifiedBy(
+                "The URL that specifies the behaviour of this scalar."
+                url: String!
+              ) on SCALAR
+
+            type Query {
+              _service: _Service!
+              foo: String! @override(from : "products")
+            }
+
+            type _Service {
+              sdl: String!
+            }
+
+            scalar link__Import
+            """.trimIndent()
+
+        val config = FederatedSchemaGeneratorConfig(
+            supportedPackages = listOf("com.expediagroup.graphql.generator.federation.directives.override"),
+            hooks = FederatedSchemaGeneratorHooks(emptyList()).apply {
+                this.linkSpecs[FEDERATION_SPEC] = FederatedSchemaGeneratorHooks.LinkSpec(
+                    namespace = "federation",
+                    imports = mapOf("override" to "override"),
+                    url = "https://specs.apollo.dev/federation/v2.0"
+                )
+            }
+        )
+        val schema = toFederatedSchema(config, listOf(TopLevelObject(Query())))
+        Assertions.assertEquals(expectedSchema, schema.print().trim())
+
+        val query = schema.getObjectType("Query")
+        assertNotNull(query)
+        val fooQuery = query.getField("foo")
+        assertNotNull(fooQuery)
+        assertNotNull(fooQuery.hasAppliedDirective(OVERRIDE_DIRECTIVE_NAME))
+    }
+
     class Query {
         @OverrideDirective(from = "products")
         fun foo(): String = "test"
+    }
+
+    class Fed27Query {
+        @OverrideDirective(from = "products")
+        fun foo(): String = "test"
 
         @OverrideDirective(from = "products", label = "percent(50)")
         fun bar(): String = "test"
     }
-
 }