export const createExchangeLink = () => {
  const httpLink = createHttpLink({
    fetch,
    uri: urljoin(EXCHANGE_API_BASE, "graphql"),
  })

  const authMiddleware = setContext((_request, context) => {
    const locals = context.graphqlContext && context.graphqlContext.res.locals
    const tokenLoader = locals && locals.dataLoaders.exchangeTokenLoader
    const headers = { ...(locals && requestIDHeaders(locals.requestIDs)) }
    // If a token loader exists for Exchange (i.e. this is an authenticated request), use that token to make
    // authenticated requests to Exchange.
    if (tokenLoader) {
      return tokenLoader().then(({ token }) => {
        return {
          headers: Object.assign(headers, { Authorization: `Bearer ${token}` }),
        }
      })
    }
    // Exchange uses no authentication for now
    return { headers }
  })

  return middlewareLink.concat(authMiddleware).concat(httpLink)
}

  .get('/oauth', async ctx => {
    const { code, path, state } = ctx.query

    if (!state || state !== ctx.session.uuid) {
      return ctx.throw('invalid oauth redirect')
    }

    const { data } = await axios.post(
      'https://github.com/login/oauth/access_token',
      {
        client_id: process.env.GITHUB_CLIENT_ID,
        client_secret: process.env.GITHUB_CLIENT_SECRET,
        code,
        state,
      },
      {
        headers: {
          Accept: 'application/json',
        },
      },
    )

    if (data.error) {
      return ctx.throw(data)
    }

    const token = data.access_token

    ctx.session.token = token

    const apollo = new ApolloClient({
      link: createHttpLink({
        uri: 'https://api.github.com/graphql',
        headers: {
          Authorization: `bearer ${token}`,
        },
      }),
      cache: new InMemoryCache(),
    })

    const { data: user } = await apollo.query<{ viewer: User }>({
      query: gql`
        query {
          viewer {
            avatarUrl
            id
            login
            name
            url
            websiteUrl
          }
        }
      `,
    })

    ctx.session.user = user.viewer

    ctx.redirect(`${path.replace(/ /g, '%2B')}`)
  })

export const createApollo = () =>
  new ApolloClient({
    link: createHttpLink({
      uri: SERVER_PREFIX + 'graphql',
    }),
    cache: new InMemoryCache(),
    ssrMode: __SERVER__,
  })

import {ApolloClient} from "apollo-client";
import {createHttpLink} from "apollo-link-http";
import {setContext} from "apollo-link-context";
import {InMemoryCache} from "apollo-cache-inmemory";
import {store} from "@/store";

const httpLink = createHttpLink({
    uri: process.env.NODE_ENV==="development"?"http://127.0.0.1:3000/api/graphql":"https://budgetarium.herokuapp.com/api/graphql",
});
const authLinkAccess = setContext((_: any, {headers}: any) => {
    // get the authentication token from local storage if it exists
    if (store.getState().auth.accessToken) {
        const token = (store.getState().auth.accessToken as any).token;
        // return the headers to the context so httpLink can read them
        return {
            headers: {
                ...headers,
                authorization: token ? `Bearer ${token}` : "",
            }
        };
    } else {
        return {
            headers: {
                ...headers,
            }
        };
    }
});


const authLinkRefresh = setContext((_: any, {headers}: any) => {

 http: ({ headers }) =>
   createHttpLink({
     uri: typeof window === 'undefined' ? process.env.API : window.__API__,
     credentials: 'same-origin',
     headers,
   }),

import { ApolloClient } from "apollo-boost"
import { InMemoryCache } from "apollo-cache-inmemory"
import gql from "graphql-tag"
import { createHttpLink } from "apollo-link-http"

const client = new ApolloClient({
  cache: new InMemoryCache(),
  link: createHttpLink({
    fetch: require("node-fetch"),
    headers: {
      foo: "bar",
    },
    uri: "http://localhost:4000/graphql",
  }),
})

export function query(): any {
  return client
    .query({
      query: gql`
        query HelloQuery {
          hello
        }
      `,
      variables: {
        foo: "bar",
      },
    })
    .then((result: any) => result.data)
}

import { ApolloClient } from 'apollo-client';
import { ApolloLink } from 'apollo-link';
import { createHttpLink } from 'apollo-link-http';
import { RestLink } from 'apollo-link-rest';
import { setContext } from 'apollo-link-context';
import { InMemoryCache } from 'apollo-cache-inmemory';
import { getEnvironmentVariables } from './utils';
import AuthService from './utils/authentication/authService';

const { graphcoolApi, devMode } = getEnvironmentVariables();
if (process.env.NODE_ENV === 'development') {
  console.log('Trying to connect to: ', graphcoolApi);
}

const httpLink = createHttpLink({ uri: graphcoolApi });
const middlewareLink = setContext(() => {
  let authHeader;
  const bearerToken = AuthService.getBearerToken();
  if (bearerToken) {
    authHeader = `Bearer ${bearerToken}`;
  }

  return {
    headers: {
      authorization: authHeader || null
      // TODO: Figure out if we should include a nonce header for graphcool
    }
  };
});

// Create a RestLink for the REST API