@neo4j/graphql/dist/schema/resolvers/query/root-connection.js

A GraphQL to Cypher query execution layer for Neo4j and JavaScript GraphQL implementations

"use strict";
/*
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [http://neo4j.com]
 *
 * This file is part of Neo4j.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.rootConnectionResolver = rootConnectionResolver;
const graphql_1 = require("graphql");
const PageInfo_1 = require("../../../graphql/objects/PageInfo");
const UnionEntityAdapter_1 = require("../../../schema-model/entity/model-adapters/UnionEntityAdapter");
const translate_1 = require("../../../translate");
const utils_1 = require("../../../utils");
const get_neo4j_resolve_tree_1 = __importDefault(require("../../../utils/get-neo4j-resolve-tree"));
const utils_2 = require("../../../utils/utils");
const sort_and_options_input_1 = require("../../generation/sort-and-options-input");
const pagination_1 = require("../../pagination");
const to_compose_1 = require("../../to-compose");
const empty_connection_1 = require("./empty-connection");
function rootConnectionResolver({ composer, entityAdapter, propagatedDirectives, isLimitRequired, schemaModel, }) {
    async function resolve(_root, args, context, info) {
        const resolveTree = (0, get_neo4j_resolve_tree_1.default)(info, { args });
        const { cypher, params } = (0, translate_1.translateRead)({
            context: { ...context, resolveTree },
            entityAdapter: entityAdapter,
            varName: "this",
        });
        const executeResult = await (0, utils_1.execute)({
            cypher,
            params,
            defaultAccessMode: "READ",
            context,
        });
        if (!executeResult.records[0]) {
            return empty_connection_1.emptyConnection;
        }
        const record = executeResult.records[0].this;
        const totalCount = (0, utils_2.isNeoInt)(record.totalCount) ? record.totalCount.toNumber() : record.totalCount;
        const connection = (0, pagination_1.createConnectionWithEdgeProperties)({
            selectionSet: resolveTree,
            source: { edges: record.edges, aggregate: record.aggregate },
            args: { first: args.first, after: args.after },
            totalCount,
        });
        return {
            totalCount,
            edges: connection.edges,
            pageInfo: connection.pageInfo,
            aggregate: connection.aggregate,
        };
    }
    const rootEdge = composer.createObjectTC({
        name: `${entityAdapter.name}Edge`,
        fields: {
            cursor: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString),
            node: `${entityAdapter.name}!`,
        },
        directives: (0, to_compose_1.graphqlDirectivesToCompose)(propagatedDirectives),
    });
    const rootConnection = composer.createObjectTC({
        name: `${entityAdapter.upperFirstPlural}Connection`,
        directives: (0, to_compose_1.graphqlDirectivesToCompose)(propagatedDirectives),
    });
    if (entityAdapter.isReadable(schemaModel)) {
        rootConnection.addFields({
            edges: rootEdge.NonNull.List.NonNull,
            totalCount: new graphql_1.GraphQLNonNull(graphql_1.GraphQLInt),
            pageInfo: new graphql_1.GraphQLNonNull(PageInfo_1.PageInfo),
        });
    }
    if (entityAdapter.isAggregable(schemaModel)) {
        rootConnection.addFields({
            aggregate: `${entityAdapter.operations.aggregateTypeNames.connection}!`,
        });
    }
    // since sort is not created when there is nothing to sort, we check for its existence
    let sortArg;
    if (!(entityAdapter instanceof UnionEntityAdapter_1.UnionEntityAdapter)) {
        sortArg = (0, sort_and_options_input_1.makeSortInput)({ entityAdapter, userDefinedFieldDirectives: new Map(), composer });
    }
    return {
        type: rootConnection.NonNull,
        resolve,
        args: {
            first: isLimitRequired ? new graphql_1.GraphQLNonNull(graphql_1.GraphQLInt) : graphql_1.GraphQLInt,
            after: graphql_1.GraphQLString,
            where: entityAdapter.operations.whereInputTypeName,
            ...(sortArg ? { sort: sortArg.NonNull.List } : {}),
        },
    };
}
//# sourceMappingURL=root-connection.js.map