apollo-schema-extend/lib/mergeResolvers.js

Extends your Apollo Server Express based graphql server with an external graphql source

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergeResolvers = void 0;
const apollo_server_express_1 = require("apollo-server-express");
const graphql_1 = require("graphql");
const ramda_1 = require("ramda");
const createOperation_1 = require("./operation/createOperation");
const mergeResolvers = (original, schema, options) => {
    return (0, ramda_1.mergeDeepLeft)(original, Object.assign(Object.assign(Object.assign({}, getQueryResolvers(schema, options)), getMutationResolvers(schema, options)), getTypeResolvers(schema)));
};
exports.mergeResolvers = mergeResolvers;
const getQueryResolvers = (schema, options) => {
    var _a;
    const queryFields = (_a = schema.getQueryType()) === null || _a === void 0 ? void 0 : _a.getFields();
    return queryFields
        ? {
            Query: (0, ramda_1.mapObjIndexed)((_, field) => createResolver(schema, field, options.dataSource.name, (options.postQuery && options.postQuery[field]) || options.defaultPostQuery, options.remapRules), queryFields),
        }
        : {};
};
const getMutationResolvers = (schema, options) => {
    var _a;
    const mutationFields = (_a = schema.getMutationType()) === null || _a === void 0 ? void 0 : _a.getFields();
    return mutationFields
        ? {
            Mutation: (0, ramda_1.mapObjIndexed)((_, field) => createResolver(schema, field, options.dataSource.name, (options.postMutation && options.postMutation[field]) || options.defaultPostMutation, options.remapRules), mutationFields),
        }
        : {};
};
const defaultPostOperation = ({ errors, data }, { field }) => {
    if (errors || !data) {
        throw new apollo_server_express_1.ApolloError(`Cannot resolve field ${field}.`, undefined, { errors });
    }
    return data[field];
};
const createResolver = (schema, field, dataSourceName, postOperation = defaultPostOperation, remapRules = {}) => (_, __, context, info) => __awaiter(void 0, void 0, void 0, function* () {
    if (info.operation.operation === 'subscription') {
        throw new Error('Operations of type subscription are not yet supported');
    }
    const fetchResult = yield context.dataSources[dataSourceName][info.operation.operation]((0, createOperation_1.createOperation)(info, schema, remapRules), {
        variables: info.variableValues,
    });
    return postOperation(fetchResult, { context, info, field });
});
const getTypeResolvers = (schema) => {
    const typeMap = schema.getTypeMap();
    const typeResolvers = Object.entries(typeMap)
        .filter(entry => entry[1] instanceof graphql_1.GraphQLInterfaceType || entry[1] instanceof graphql_1.GraphQLUnionType)
        .reduce((total, next) => {
        total[next[0]] = {
            __resolveType(entity) {
                return entity.__typename;
            },
        };
        return total;
    }, {});
    return typeResolvers;
};