@neo4j/cypher-builder/dist/clauses/utils/concat.js

A programmatic API for building Cypher queries for Neo4j

"use strict";
/*
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [http://neo4j.com]
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.CompositeClause = void 0;
const filter_truthy_1 = require("../../utils/filter-truthy");
const Clause_1 = require("../Clause");
/** The result of multiple clauses concatenated with `Cypher.utils.concat`
 * @group Utils
 */
class CompositeClause extends Clause_1.Clause {
    separator;
    _children;
    /**
     * @internal
     */
    constructor(children, separator) {
        super();
        this.separator = separator;
        this._children = [];
        this.concat(...children);
    }
    concat(...clauses) {
        const filteredChildren = this.filterClauses(clauses);
        this.addChildren(...filteredChildren);
        this._children = [...this._children, ...filteredChildren];
        return this;
    }
    get empty() {
        return this._children.length === 0;
    }
    /** @internal */
    getCypher(env) {
        // NOTE: importWithCypher used to pass down import WITH to UNION clauses
        const childrenStrs = this._children.map((c) => {
            return c.getCypher(env);
        });
        return childrenStrs.join(this.separator);
    }
    filterClauses(clauses) {
        const childrenRoots = (0, filter_truthy_1.filterTruthy)(clauses).map((c) => c.getRoot());
        return this.filterEmptyComposite(childrenRoots).map((c) => {
            if (c instanceof CompositeClause) {
                return this.unwrapComposite(c);
            }
            return c;
        });
    }
    filterEmptyComposite(children) {
        return children.filter((c) => {
            if (c instanceof CompositeClause && c.empty)
                return false;
            return true;
        });
    }
    unwrapComposite(clause) {
        if (clause._children.length === 1) {
            return clause._children[0];
        }
        else
            return clause;
    }
}
exports.CompositeClause = CompositeClause;