@neo4j/graphql/dist/schema/resolvers/mutation/update.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.updateResolver = updateResolver;
const debug_1 = __importDefault(require("debug"));
const graphql_1 = require("graphql");
const constants_1 = require("../../../constants");
const QueryASTFactory_1 = require("../../../translate/queryAST/factory/QueryASTFactory");
const callback_bucket_1 = require("../../../translate/queryAST/utils/callback-bucket");
const build_clause_1 = require("../../../translate/utils/build-clause");
const utils_1 = require("../../../utils");
const get_neo4j_resolve_tree_1 = __importDefault(require("../../../utils/get-neo4j-resolve-tree"));
const debug = (0, debug_1.default)(constants_1.DEBUG_TRANSLATE);
function updateResolver({ concreteEntityAdapter, }) {
    async function resolve(_root, args, context, info) {
        const resolveTree = (0, get_neo4j_resolve_tree_1.default)(info, { args });
        context.resolveTree = resolveTree;
        const { cypher, params } = await translateUpdate({
            context: context,
            entityAdapter: concreteEntityAdapter,
        });
        const executeResult = await (0, utils_1.execute)({
            cypher,
            params,
            defaultAccessMode: "WRITE",
            context,
            info,
        });
        const nodeProjection = info.fieldNodes[0]?.selectionSet?.selections.find((selection) => {
            return selection.kind === graphql_1.Kind.FIELD && selection.name.value === concreteEntityAdapter.plural;
        });
        const resolveResult = {
            info: {
                ...executeResult.statistics,
            },
        };
        if (nodeProjection) {
            const nodeKey = nodeProjection.alias ? nodeProjection.alias.value : nodeProjection.name.value;
            resolveResult[nodeKey] = executeResult.records.map((x) => x.this);
        }
        return resolveResult;
    }
    const relationFields = {};
    return {
        type: `${concreteEntityAdapter.operations.mutationResponseTypeNames.update}!`,
        resolve,
        args: {
            where: concreteEntityAdapter.operations.updateMutationArgumentNames.where,
            update: concreteEntityAdapter.operations.updateMutationArgumentNames.update,
            ...relationFields,
        },
    };
}
async function translateUpdate({ context, entityAdapter, }) {
    const { resolveTree } = context;
    const varName = "this";
    const operationsTreeFactory = new QueryASTFactory_1.QueryASTFactory(context.schemaModel);
    const callbackBucket = new callback_bucket_1.CallbackBucket(context);
    const operationsTree = operationsTreeFactory.createMutationAST({
        resolveTree,
        entityAdapter,
        context,
        varName,
        callbackBucket,
    });
    debug(operationsTree.print());
    await callbackBucket.resolveCallbacks();
    const clause = operationsTree.build(context, varName);
    return (0, build_clause_1.buildClause)(clause, { context });
}
//# sourceMappingURL=update.js.map