How to dynamically update the link headers in the binding instance ?

I use graphql-binding in an express server to query another graphql server. On each request, I need to pass a header whose value changes everytime (it comes from the express req object and it is used for tracing ). I create a new HttpLink and a new GraphQLServiceBinding instance each time, but it creates a memory leak on my server (see code below).

Is there a way to dynamically change the headers in my link instance without re-creating a new instance of GraphQLServiceBinding each time ?

I use the function getGraphqlClient to create a graphql client in all my requests:

import { introspectSchema } from 'graphql-tools'
import fetch from 'node-fetch'
import { HttpLink } from 'apollo-link-http'
import { Binding } from 'graphql-binding'
import { makeRemoteExecutableSchema } from 'graphql-tools'

const graphqlServerUrl = process.env.GRAPHQL_URL

class GraphQLServiceBinding extends Binding {
  constructor(introspectedSchema, link) {
    const schema = makeRemoteExecutableSchema({
      link,
      schema: introspectedSchema,
    })

    super({ schema })
  }
}

let cachedSchema = null

async function getCachedSchema(link) {
  if (cachedSchema) return cachedSchema
  cachedSchema = await introspectSchema(link)
  return cachedSchema
}

// function getGraphqlClient is used to instantiate a new binding with specific headers
export const getGraphqlClient = async (graphQLServerUrl, headers = {}) => {
  const uri = graphQLServerUrl || process.env.GRAPHQL_URL
  if (!uri) {
    throw new Error('GRAPHQL_URL variable is mandatory')
  }

  try {
    // the headers change on every request
    const link = new HttpLink({ uri, fetch, headers })
    // the schema doesn't change
    const schema = await getCachedSchema(link)
    const binding = new GraphQLServiceBinding(schema, link)

    return binding
  } catch (err) {
    console.error(
      `Error introspecting remote schema on url ${graphQLServerUrl}`
    )
    throw err
  }
}

[lambrojos]

You can use the apollo-link-context module to set headers based on the request context:

const fetch = require('node-fetch');
const { Binding } = require('graphql-binding');
const { HttpLink } = require('apollo-link-http');
const { makeRemoteExecutableSchema, introspectSchema } = require('graphql-tools');
const { setContext } = require('apollo-link-context');

const http = new HttpLink({ uri: process.env.GRAPHQL_ENDPOINT, fetch });
const link = setContext((request, { graphqlContext }) => (
  graphqlContext ? {
    headers: {
      Authorization: `Bearer ${graphqlContext.auth}`,
    },
  } : {})).concat(http);

const schemaPromise = introspectSchema(link);

module.exports.graphql = schemaPromise
  .then(typeDefs => new class GraphQLBinding extends Binding {
    constructor() {
      super({
        schema: makeRemoteExecutableSchema({ link, schema: typeDefs }),
      });
    }
  }());

You can specify the context as a property of the third parameter in your bindings:

  const auth = 'auth token';
  const result = await bindings.query.whatevers({
    skip: 0,
    limit: 10,
  }, `{ items { id, body }}`, { context: { auth } });

[Urigo]

@timotgl could you share a simple example in a repo? then we could PR it with a couple of options so you could compare