@atomist/automation-client/lib/graph/ApolloGraphClient.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const apollo_cache_inmemory_1 = require("apollo-cache-inmemory");
const apollo_client_1 = require("apollo-client");
const apollo_link_1 = require("apollo-link");
const apollo_link_error_1 = require("apollo-link-error");
const apollo_link_http_1 = require("apollo-link-http");
const axios_1 = require("axios");
const axios_fetch_1 = require("axios-fetch");
const graphql_tag_1 = require("graphql-tag");
const stringify = require("json-stringify-safe");
const trace = require("stack-trace");
const internalGraphql = require("../internal/graph/graphQL");
const namespace = require("../internal/util/cls");
const http_1 = require("../internal/util/http");
const string_1 = require("../internal/util/string");
const logger_1 = require("../util/logger");
graphql_tag_1.disableFragmentWarnings();
/**
 * Implementation of GraphClient using Apollo Client.
 */
class ApolloGraphClient {
    /**
     * Create a new GraphClient
     * @param endpoint GraphQL endpoint
     * @param headers any special headers to use
     * @param fetch configured GlobalFetch instance to use for this GraphClient
     */
    constructor(endpoint, headers = {}, fetch = axios_fetch_1.buildAxiosFetch(axios_1.default.create(http_1.configureProxy({}))), listeners = []) {
        this.endpoint = endpoint;
        this.headers = headers;
        this.fetch = fetch;
        this.listeners = listeners;
        const cache = new apollo_cache_inmemory_1.InMemoryCache({
            addTypename: false,
        });
        const httpLink = apollo_link_http_1.createHttpLink({
            uri: endpoint,
            fetch,
        });
        const middlewareLink = new apollo_link_1.ApolloLink((operation, forward) => {
            // attach the correlation-id to the request
            const correlationId = namespace.get() ? namespace.get().correlationId : undefined;
            if (!!correlationId) {
                headers["correlation-id"] = correlationId;
            }
            const invocationId = namespace.get() ? namespace.get().invocationId : string_1.guid();
            if (!!invocationId) {
                headers["x-request-id"] = invocationId;
            }
            operation.setContext({
                headers,
            });
            for (const listener of this.listeners) {
                operation = listener.operationStarting(operation);
            }
            return forward(operation);
        });
        const errorLink = apollo_link_error_1.onError(({ graphQLErrors, networkError, response }) => {
            let msg = `GraphQL operation failed:`;
            if (!!graphQLErrors) {
                const g = graphQLErrors.map(({ message }) => ` [GraphQL]: ${message}`);
                msg += `${g.join(" ")}`;
            }
            if (!!networkError) {
                msg += ` [Network]: ${networkError}`;
            }
            if (!!response) {
                msg += ` [Response]: ${stringify(response, string_1.replacer)}`;
            }
            logger_1.logger.error(msg);
        });
        const link = errorLink.concat(middlewareLink.concat(httpLink));
        this.client = new apollo_client_1.default({
            link,
            cache,
        });
    }
    query(options) {
        if (typeof options === "string") {
            options = {
                name: options,
            };
        }
        const q = internalGraphql.query({
            query: options.query,
            path: options.path,
            name: options.name,
            moduleDir: options.moduleDir ? options.moduleDir : trace.get()[1].getFileName(),
        });
        return this.executeQuery(q, options.variables, options.options);
    }
    mutate(options) {
        if (typeof options === "string") {
            options = {
                name: options,
            };
        }
        const m = internalGraphql.mutate({
            mutation: options.mutation,
            path: options.path,
            name: options.name,
            moduleDir: options.moduleDir ? options.moduleDir : trace.get()[1].getFileName(),
        });
        return this.executeMutation(m, options.variables, options.options);
    }
    executeQuery(q, variables, queryOptions) {
        const log = !queryOptions ||
            (queryOptions && queryOptions.log === undefined) ||
            (queryOptions && queryOptions.log === true);
        if (log) {
            logger_1.logger.debug(`Querying '%s' with variables '%s' and query: %s`, this.endpoint, stringify(variables || {}), internalGraphql.inlineQuery(q));
        }
        const query = graphql_tag_1.default(q);
        return this.client.query(Object.assign({ query,
            variables, errorPolicy: "all" }, queryOptions))
            .then(result => {
            if (log) {
                // The following statement is needed for debugging; we can always disable that later
                logger_1.logger.debug("Query returned data: %s", stringify(result.data, string_1.replacer));
            }
            return result.data;
        });
    }
    executeMutation(m, variables, mutationOptions) {
        const log = !mutationOptions ||
            (mutationOptions && mutationOptions.log === undefined) ||
            (mutationOptions && mutationOptions.log === true);
        if (log) {
            logger_1.logger.debug(`Mutating '%s' with variables '%s' and mutation: %s`, this.endpoint, stringify(variables || {}), internalGraphql.inlineQuery(m));
        }
        const mutation = graphql_tag_1.default(m);
        return this.client.mutate(Object.assign({ mutation,
            variables, errorPolicy: "all" }, mutationOptions))
            .then(response => {
            if (log) {
                // The following statement is needed for debugging; we can always disable that later
                logger_1.logger.debug("Mutation returned data: %s", stringify(response.data, string_1.replacer));
            }
            return response.data;
        });
    }
}
exports.ApolloGraphClient = ApolloGraphClient;
//# sourceMappingURL=ApolloGraphClient.js.map