How to use the apollo-link.ApolloLink.from function in apollo-link

)

  const errorLink = onError(
    ({ graphQLErrors, networkError }) => {
      if (graphQLErrors) {
        graphQLErrors.map(err => {
          store.dispatch(openSnackbar({message: err.message, autoHideDuration: 3000}))
        })
      }
      if (networkError) {
        store.dispatch(openSnackbar({message: networkError, autoHideDuration: 3000}))
      }
    }
  )

  let link = ApolloLink.from([errorLink, contextLink, httpLink])

  if (!ssrMode) {

    const wsLink = new WebSocketLink(
      createSubscriptionClient({
        wsUrl: WS_URL,
        store,
        getToken,
      })
    )
    const subscriptionLink = ApolloLink.from([errorLink, wsLink])
        
    // using the ability to split links, you can send data to each link
    // depending on what kind of operation is being sent
    link = split(
      isSubscriptionOperation,

function create(initialState) {
  const httpLink = createHttpLink({
    uri: `${uri()}/graphql`,
    credentials: "same-origin"
  });

  // Check out https://github.com/zeit/next.js/pull/4611 if you want to use the AWSAppSyncClient
  return new ApolloClient({
    connectToDevTools: process.browser,
    ssrMode: !process.browser,
    link: ApolloLink.from([
      errorLink,
      httpLink,
    ]),
    cache: new InMemoryCache().restore(initialState || {})
  });
}

graphQLErrors.forEach(err => console.error(`[GraphQL error]: Message: ${err.message}`));
    }

    if (networkError) {
      console.error(`[Network error]: ${networkError}`);
    }
  });

  const contextLink = setContext((_, { headers }) => ({
    headers: {
      ...headers,
      authorization: auth.isLogged(ctx) ? `Bearer ${auth.token(ctx)}` : ''
    }
  }));

  const link = ApolloLink.from([errorLink, contextLink, httpLink]);

  return new ApolloClient({
    link,
    ssrMode: !process.browser,
    cache: new InMemoryCache().restore(initialState || {})
  });
});

}
        }

        cache.writeQuery({ query, data })
        return null;
      },
      resetCurrentGame: (_, d, { cache }) => {
        cache.writeData({ data : defaultState })
        return null;
      }
    }
  }
})

const client = new ApolloClient({
  link: ApolloLink.from([
    stateLink,
    new HttpLink({
      uri: 'https://api.graph.cool/simple/v1/cjbl0bxmq04570186hqlvgpmg'
    })
  ]),
  cache
})

ReactDOM.render(
  
    
      <div>
        
        
      </div>

const cache = new InMemoryCache({
    dataIdFromObject: () => null,
    fragmentMatcher: new IntrospectionFragmentMatcher({
      introspectionQueryResultData,
    }),
  });

  const observableApi = new AppKibanaObservableApiAdapter({
    basePath: chrome.getBasePath(),
    xsrfToken: chrome.getXsrfToken(),
  });

  const graphQLOptions = {
    connectToDevTools: process.env.NODE_ENV !== 'production',
    cache,
    link: ApolloLink.from(getLinks(cache)),
  };

  const apolloClient = new ApolloClient(graphQLOptions);

  const appModule = uiModules.get('app/siem');

  const framework = new AppKibanaFrameworkAdapter(appModule, uiRoutes, timezoneProvider);

  const libs: AppFrontendLibs = {
    apolloClient,
    framework,
    observableApi,
  };
  return libs;
}

handle.unsubscribe();
                }
              };
            }),
        )
      : false;

    const httpLink = new HttpLink({
      uri: uri || '/graphql',
      fetch,
      fetchOptions: fetchOptions || {},
      credentials: credentials || 'same-origin',
      headers: headers || {},
    });

    const link = ApolloLink.from([errorLink, requestHandler, httpLink].filter(
      x => !!x,
    ) as ApolloLink[]);

    let activeResolvers = resolvers;
    let activeTypeDefs = typeDefs;
    let activeFragmentMatcher = fragmentMatcher;
    if (clientState) {
      if (clientState.defaults) {
        cache.writeData({
          data: clientState.defaults,
        });
      }
      activeResolvers = clientState.resolvers;
      activeTypeDefs = clientState.typeDefs;
      activeFragmentMatcher = clientState.fragmentMatcher;
    }

import ApolloClient from "apollo-client";
import { ApolloLink } from "apollo-link";
import { BatchHttpLink } from "apollo-link-batch-http";
import { InMemoryCache } from "apollo-cache-inmemory";
import { createAuthLink } from "webiny-app-security/components";
import { createOmitTypenameLink } from "webiny-app/graphql";

export default new ApolloClient({
    link: ApolloLink.from([
        createOmitTypenameLink(),
        createAuthLink(),
        new BatchHttpLink({ uri: process.env.REACT_APP_FUNCTIONS_HOST + "/function/api" })
    ]),
    cache: new InMemoryCache({
        addTypename: true,
        dataIdFromObject: obj => obj.id || null
    })
});

operation.setContext(({ headers }) => ({
    headers: {
      'X-Drago-Token': `${localStorage.getItem('drago.settings.acl.token')}`,
      ...headers,
    },
  }))
  return forward(operation)
})

const errorLink = onError(error => {
  if (DEBUG) {
    log.errors(error)
  }
})

const link = ApolloLink.from([authLink, errorLink, restLink])

const inMemoryCache = new InMemoryCache()

export default new ApolloClient({
  link,
  cache: inMemoryCache,
  connectToDevTools: true,
  typeDefs: {},
})