Force request header depending on request type

[rb090]

Hello 👋,

I am using an instance of DefaultKtorGraphQLContextFactory for header handling. It looks like this:

class HeaderContextFactory : DefaultKtorGraphQLContextFactory() {
    override suspend fun generateContext(request: ApplicationRequest): GraphQLContext =
        super.generateContext(request)
            .plus(map = mapOf(pair = IDEMPOTENCY_REQUEST_HEADER to request.header(name = IDEMPOTENCY_REQUEST_HEADER)))
}

This also enforces the headers to be present in the request. If header is not in the request, the server answers with 400. This makes totally sense ✅.

Can you please tell me, how to change this if we want to enforce header only for specific request types? The idempotency header makes only sense for mutation requests. Queries don't need to send it.

Is there anything which makes an if possible? Sth like this?

    override suspend fun generateContext(request: ApplicationRequest): GraphQLContext =
        if (request.xxx.xxxx.... is Mutation) {
            super.generateContext(request)
                .plus(map = mapOf(pair = IDEMPOTENCY_REQUEST_HEADER to request.header(name = IDEMPOTENCY_REQUEST_HEADER)))
        } else {
            super.generateContext(request)
        }

[rb090]

I am really thankful for each hint on this :). @dariuszkuc Can you please help me on this? You are one of the big magicians with Kotlin graphql.

[rb090]

Thanks a lot @dariuszkuc for your response. I set the HeaderContextFactory atm like this within server. contextFactory:

install(GraphQL) {
   schema {
      packages = listOf("xxx.xxxx.xxxx")
         queries = listOf(MyQueryService())
         mutations = listOf(MyMutationService())
      }
      server {
        contextFactory = HeaderContextFactory()
      }
  }
}

That leads to the problem that the headers read in HeaderContextFactory are always expected on each operation (mutation and query). But the headers from HeaderContextFactory are only required for a couple of operations.

I guess the solution for my problem is exactly what you wrote:

In general I'd use some custom directive that would verify your execution requirements (i.e. whether your headers are present/valid in the context)

Can you please tell me how to use such a custom directive?

[dariuszkuc]

See docs or search through discussions (there were a number of conversations around auth and directives).

[rb090]

Hi @dariuszkuc 👋,

I had a look at the Custom Directives within the expediagroup docs. My thoughts were that I need to implement sth similar to this and then customize the behavior like described in Customizing Behavior to modify the behavior of the graphql operations. But I have no idea if I am on the right path 😣.

If I understand the idea of this custom directives:

• I would need to somehow set the HeaderContextFactory which enforces the presence of the IDEMPOTENCY_REQUEST_ID header within a KotlinSchemaDirectiveWiring? Can you please help me here?

class MutationIdempotencyHeaderDirectiveWiring : KotlinSchemaDirectiveWiring {

    override fun onField(environment: KotlinFieldDirectiveEnvironment): GraphQLFieldDefinition {
        val originalDataFetcher: DataFetcher<*> = environment.getDataFetcher()

        val enforceIdempotencyHeaderDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher) { env, _ ->
            val context = env.graphQlContext
            
            // -> Add here `HeaderContextFactory` to context?
        }

        environment.setDataFetcher(enforceIdempotencyHeaderDataFetcher)

        return super.onField(environment)
    }
}

• define an annotation class for my custom GraphQLDirective?

@GraphQLDirective(
    name = "idempotencyRequestId",
    locations = [Introspection.DirectiveLocation.FIELD_DEFINITION]
)
annotation class IdempotencyRequestKeyDirective

• Annotate my mutation? I need to grab the idempotency request header within my mutation, this is sth I can still do with DataFetchingEnvironment?

class MyMutationService : Mutation {

    @IdempotencyRequestKeyDirective
    fun mutation(
        user: User,
        env: DataFetchingEnvironment
    ): MyResult {
        val idempotencyRequestId: String = env.graphQlContext.get(IDEMPOTENCY_REQUEST_ID)
        return processSthReturningMyResult(user = user, idempotencyRequestId = idempotencyRequestId)
    }
}

• Setup in the application class would look sth like this?

    install(GraphQL) {

        schema {
            packages = listOf("my.service.app")
            queries = listOf(MyQuery())
            mutations = listOf(MyMutation())

            val customWiringFactory = KotlinDirectiveWiringFactory(
                manualWiring = mapOf<String, KotlinSchemaDirectiveWiring>("idempotencyRequestId" to MutationIdempotencyHeaderDirectiveWiring())
            )

            hooks = object : SchemaGeneratorHooks {
                override val wiringFactory: KotlinDirectiveWiringFactory
                    get() = customWiringFactory
            }
        }
    }

That is at least my understanding from the docs I read. I have the feeling that it is probably wrong 😓.

More then this I believe atm that I am on the wrong path with the custom directives to enforce idempotency header only for mutations. For my understanding this custom directives are more for single field annotation/manipulation (like in your samples where a field value gets lowercased).

I really appreciate every advice here and thanks in regards for the help here with this topic.

[dariuszkuc]

You are on the "right" path -> you already configured your context factory through

server {
  contextFactory = HeaderContextFactory()
}

So you just need to access the value from the context in your directive wiring and then decide whether to proceed with the call or return failure.

[rb090]

Hi @dariuszkuc,

thanks a lot for your answer on this. You are right 👍.

I implemented my MutationIdempotencyHeaderDirectiveWiring now like this:

class MutationIdempotencyHeaderDirectiveWiring : KotlinSchemaDirectiveWiring {

    override fun onField(environment: KotlinFieldDirectiveEnvironment): GraphQLFieldDefinition {
        val originalDataFetcher: DataFetcher<*> = environment.getDataFetcher()

        val idempotentDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher) { env, _ ->
            val idempotencyKey: String? = env.graphQlContext[IDEMPOTENCY_REQUEST_ID]

            if (idempotencyKey != null) {
                originalDataFetcher.get(env)
            } else {
                null
            }
        }

        environment.setDataFetcher(idempotentDataFetcher)

        return super.onField(environment)
    }
}

But I also needed to change my HeaderContextFactory a bit like this:

class HeaderContextFactory : DefaultKtorGraphQLContextFactory() {
    override suspend fun generateContext(request: ApplicationRequest): GraphQLContext =
        super.generateContext(request).plus(
            map = mapOf(IDEMPOTENCY_REQUEST_ID to (request.header(name = IDEMPOTENCY_REQUEST_ID) ?: ""))
        )
}

Without this change, each request made without idempotency request header (fe. a query) would be rejected by the server immediately with a 400.

Now requests are not rejected anymore when they do not contain the idempotency header 🥳.

The "enforcement" of the header needs to happen now in the corresponding mutation function:

class MyMutationService : Mutation {

    @IdempotencyRequestKeyDirective
    fun mutation(
        user: User,
        env: DataFetchingEnvironment
    ): MyResult {
        val idempotencyRequestId = env.graphQlContext.stream()
            .filter { it.key == IDEMPOTENCY_REQUEST_ID }
            .map { it.value as String }
            .findFirst()
            .orElse(null)

        return if (idempotencyRequestId.isNullOrEmpty()) {
            val missingIdempotencyRequestId = Error(
                title = "Missing $IDEMPOTENCY_REQUEST_ID header",
                message = "Please ensure you send $IDEMPOTENCY_REQUEST_ID in the header correctly. We expect it within this request!",
            )
            MyResult(success = null, error = missingIdempotencyRequestId)
        } else {
            processSthReturningMyResult(user = user, idempotencyRequestId = idempotencyRequestId)
        }
    }
}

One more question please @dariuszkuc, the annotation of MyMutationService.mutation function with @IdempotencyRequestKeyDirective is still needed? I would guess it is not because of the setup in the application class within schema:

schema {
            packages = listOf("xxx.xxxx.xxxx")
            queries = listOf(MyQuery())
            mutations = listOf(MyMutation())

            val customWiringFactory = KotlinDirectiveWiringFactory(
                manualWiring = mapOf<String, KotlinSchemaDirectiveWiring>("idempotencyRequestId" to MutationIdempotencyHeaderDirectiveWiring())
            )

            hooks = object : SchemaGeneratorHooks {
                override val wiringFactory: KotlinDirectiveWiringFactory
                    get() = customWiringFactory
            }
        }

[rb090]

I think I was totally wrong on this. It looks that no KotlinSchemaDirectiveWiring is needed? I removed the KotlinSchemaDirectiveWiring, the GraphQLDirective and the hooks setup from the Application and everything is working.

From what I saw, KotlinSchemaDirectiveWiring.onField was executed after my MyMutationService.mutation call. Which is too late for a header check. Somehow I thought that KotlinSchemaDirectiveWiring.onField is executed before MyMutationService.mutation...

[dariuszkuc]

As you noticed there are multiple ways to implement this

1. using directives to enforce it (proposed originally) -> no need to have extra logic within the mutation function, you only need to annotate it with directive and provide the wiring logic
2. manually check for the header in the function (your latest approach) -> if you do the explicit check within the mutation function there is no need for directives as it will be duplicating the logic

[rb090]

Hi @dariuszkuc,

thanks a lot for getting back to me here.

I really like the KotlinSchemaDirectiveWiring.onField, my problem here is that this method gets executed after the code within MyMutationService.mutation was executed.

And the header check needs to happen before my code within MyMutationService.mutation runs. Ideally the mutation should not even be executed if the idempotency header is missing.

Today I added an if within my MutationIdempotencyHeaderDirectiveWiring which checked weather operation is a mutation and if there is the idempotency header:

class MutationIdempotencyHeaderDirectiveWiring : KotlinSchemaDirectiveWiring {
    override fun onField(environment: KotlinFieldDirectiveEnvironment): GraphQLFieldDefinition {
        val originalDataFetcher: DataFetcher<*> = environment.getDataFetcher()

        val idempotentDataFetcher =
            DataFetcherFactories.wrapDataFetcher(originalDataFetcher) { env, _ ->
                val idempotencyKey: String? = env.graphQlContext[IDEMPOTENCY_REQUEST_ID]

                if (env.executionStepInfo.objectType.name == "Mutation" && idempotencyKey.isNullOrEmpty()) {
                    throw IllegalStateException("Missing $IDEMPOTENCY_REQUEST_ID header in the request. Please ensure the header is sent correctly for Mutations!")
                }

                if (idempotencyKey != null) {
                    // Proceed with the original data fetcher
                    originalDataFetcher.get(env)
                } else {
                    null
                }
            }

        environment.setDataFetcher(idempotentDataFetcher)

        return super.onField(environment)
    }
}

But I saw that my IllegalStateException was thrown after the MyMutationService.mutation was processed. I am sure this is because sth is wrong within my configuration or in my code. I just didn't knew what it was...