@jetshop/core/boot/apollo.js

import { ApolloClient } from 'apollo-client';
import { ApolloLink } from 'apollo-link';
import { onError } from 'apollo-link-error';
import { createHttpLink } from 'apollo-link-http';
import { createPersistedQueryLink } from 'apollo-link-persisted-queries';
import { SchemaLink } from 'apollo-link-schema';
import get from 'lodash.get';
import qs from 'qs';
import { createNetworkStatusNotifier } from 'react-apollo-network-status';
import createCache from '../data/cache';
import report from '../errorReporting';
import { resolvers } from '../resolvers';
import typeDefs from './client-schema.gql';
import { logOperationTime } from './utils/queryLoggingMiddleware';
export const createClient = ({ apolloConfig: { token, shopid, enableGateway, graphQLURI }, schema, authHandler, channelHandler, previewHandler, req }) => {
    if (!token || !shopid) {
        throw new Error(`Missing ${!token && `token`} ${!shopid && `shopid`}`);
    }
    const channelHeaders = channelHandler
        ? channelHandler.getChannelHeaders()
        : {};
    const authHeaders = authHandler ? authHandler.getAuthHeaders() : {};
    const previewHeaders = previewHandler
        ? previewHandler.getPreviewHeaders()
        : {};
    const createGatewayLink = () => __IN_SERVER__
        ? schema
            ? new SchemaLink({
                schema,
                context: {
                    headers: Object.assign(Object.assign(Object.assign({}, channelHeaders), authHeaders), previewHeaders)
                }
            })
            : createHttpLink({
                uri: `http://localhost:${process.env.PORT || 3000}/graphql`,
                headers: {},
                fetch: require('node-fetch').default
            })
        : createHttpLink({
            uri: '/graphql',
            headers: {}
        });
    const createDirectLink = () => {
        if (__IN_SERVER__) {
            return createHttpLink({
                uri: graphQLURI,
                headers: {
                    token: token,
                    shopid: shopid
                },
                fetch: require('node-fetch').default,
                fetchOptions: {
                    agent: graphQLURI.indexOf('https') === 0
                        ? new (require('https').Agent)({
                            keepAlive: true
                        })
                        : undefined
                }
            });
        }
        return createHttpLink({
            uri: graphQLURI,
            headers: {
                token: token,
                shopid: shopid
            },
            fetchOptions: {
                keepAlive: true
            }
        });
    };
    const apiLink = enableGateway ? createGatewayLink() : createDirectLink();
    const channelMiddleware = channelHandler &&
        new ApolloLink((operation, forward) => {
            // Sets the current channel before each new HTTP request is made
            operation.setContext(({ headers = {} }) => ({
                headers: Object.assign(Object.assign({}, headers), channelHandler.getChannelHeaders())
            }));
            return forward ? forward(operation) : null;
        });
    const authMiddleware = authHandler &&
        new ApolloLink((operation, forward) => {
            // Sets the auth token when a new request is made
            authHandler.loadAuthToken();
            operation.setContext(({ headers = {} }) => ({
                headers: Object.assign(Object.assign({}, headers), authHandler.getAuthHeaders())
            }));
            return forward ? forward(operation) : null;
        });
    const previewMiddleware = previewHandler &&
        new ApolloLink((operation, forward) => {
            operation.setContext(({ headers = {} }) => ({
                headers: Object.assign(Object.assign({}, headers), previewHandler.getPreviewHeaders())
            }));
            return forward ? forward(operation) : null;
        });
    const errorMiddleware = onError(({ graphQLErrors, networkError, operation }) => {
        if (graphQLErrors) {
            graphQLErrors.forEach(error => {
                const code = get(error, 'extensions.code');
                if (code === 'EmptyRoute') {
                    console.log(`[404 error at ${operation.variables.path}]`);
                    report(new Error(`MissingRoute: Attempted to access ${operation.variables.path}`));
                }
                else if (code === 'InvalidToken') {
                    authHandler.clearAuthToken();
                    if (typeof window !== 'undefined') {
                        window.location.href = '/';
                    }
                }
                else {
                    console.log(error);
                    // Other graph errors will be logged to Sentry
                    report(new Error(`${error.message || code}`), {
                        // Include all operation details (query etc)
                        operation,
                        code,
                        error
                    });
                }
            });
        }
        // 503
        if (networkError) {
            console.log(`[Network error]: ${networkError}`);
            report(networkError);
        }
    });
    const { link: networkStatusNotifierLink, NetworkStatusNotifier } = createNetworkStatusNotifier();
    const links = [
        errorMiddleware,
        // Only add the middleware to the links array if the exist
        ...(channelMiddleware ? [channelMiddleware] : []),
        ...(authMiddleware ? [authMiddleware] : []),
        ...(previewMiddleware ? [previewMiddleware] : []),
        networkStatusNotifierLink,
        apiLink
    ];
    if (process.env.DEBUG_MODE === 'true') {
        links.unshift(logOperationTime);
    }
    if (enableGateway) {
        links.unshift(createPersistedQueryLink({ useGETForHashedQueries: true }));
    }
    const link = ApolloLink.from(links);
    const cache = createCache();
    const client = new ApolloClient({
        link,
        assumeImmutableResults: true,
        cache: __IN_SERVER__
            ? cache
            : cache.restore(window.__APOLLO_STATE__),
        ssrMode: !!__IN_SERVER__,
        resolvers: resolvers(qs.stringify(req === null || req === void 0 ? void 0 : req.query, { encode: true, encodeValuesOnly: true })),
        typeDefs
    });
    return { client, NetworkStatusNotifier };
};
//# sourceMappingURL=apollo.js.map