Merge pull request #5597 from neo4j/update-cypher-builder

Update cypher builder
neo4j · Sep 26, 2024 · a067e31 · a067e31
2 parents 89b26fd + 013dd2e
commit a067e31
Show file tree

Hide file tree

Showing 37 changed files with 115 additions and 104 deletions.
diff --git a/packages/graphql/package.json b/packages/graphql/package.json
@@ -79,7 +79,7 @@
         "@graphql-tools/resolvers-composition": "^7.0.0",
         "@graphql-tools/schema": "10.0.4",
         "@graphql-tools/utils": "^10.0.0",
-        "@neo4j/cypher-builder": "^1.17.1",
+        "@neo4j/cypher-builder": "^1.20.1",
         "camelcase": "^6.3.0",
         "debug": "^4.3.4",
         "dot-prop": "^6.0.1",

diff --git a/packages/graphql/src/translate/authorization/create-authorization-after-predicate.ts b/packages/graphql/src/translate/authorization/create-authorization-after-predicate.ts
@@ -76,7 +76,7 @@ export function createAuthorizationAfterPredicate({
 
         const preComputedSubqueries = [...asArray(extraSelections), ...asArray(nodeSubqueries)];
         if (preComputedSubqueries) {
-            subqueries = Cypher.concat(subqueries, ...preComputedSubqueries);
+            subqueries = Cypher.utils.concat(subqueries, ...preComputedSubqueries);
         }
     }
     if (!predicates.length) {
@@ -138,7 +138,7 @@ export function createAuthorizationAfterPredicateField({
                 const fieldSubqueries = attributesFilters.getSubqueries(queryASTContext);
                 const preComputedSubqueries = [...asArray(fieldSelection), ...asArray(fieldSubqueries)];
                 if (preComputedSubqueries) {
-                    subqueries = Cypher.concat(subqueries, ...preComputedSubqueries);
+                    subqueries = Cypher.utils.concat(subqueries, ...preComputedSubqueries);
                 }
                 if (fieldPredicate) {
                     predicates.push(fieldPredicate);

diff --git a/packages/graphql/src/translate/authorization/create-authorization-before-predicate.ts b/packages/graphql/src/translate/authorization/create-authorization-before-predicate.ts
@@ -74,7 +74,7 @@ export function createAuthorizationBeforePredicate({
 
             const preComputedSubqueries = [...extraSelections, ...nodeSubqueries];
             if (preComputedSubqueries) {
-                subqueries = Cypher.concat(subqueries, ...preComputedSubqueries);
+                subqueries = Cypher.utils.concat(subqueries, ...preComputedSubqueries);
             }
         });
     }
@@ -141,7 +141,7 @@ export function createAuthorizationBeforePredicateField({
 
                 const preComputedSubqueries = [...fieldSelection, ...fieldSubqueries];
                 if (preComputedSubqueries) {
-                    subqueries = Cypher.concat(subqueries, ...preComputedSubqueries);
+                    subqueries = Cypher.utils.concat(subqueries, ...preComputedSubqueries);
                 }
                 if (fieldPredicate) predicates.push(fieldPredicate);
             });

diff --git a/packages/graphql/src/translate/create-connect-or-create-and-params.ts b/packages/graphql/src/translate/create-connect-or-create-and-params.ts
@@ -106,22 +106,17 @@ export function createConnectOrCreateAndParams({
             ? new Cypher.Return([new Cypher.NamedVariable("meta"), "update_meta"])
             : new Cypher.Return([Cypher.count(new Cypher.Raw("*")), "_"]);
 
-        const withStatement = new Cypher.With(...withVarsVariables);
+        const subqueryClause = new Cypher.With(...withVarsVariables)
+            .call(Cypher.utils.concat(statement, returnStatement))
+            .importWith(...withVarsVariables);
 
-        const callStatement = new Cypher.Call(Cypher.concat(statement, returnStatement)).importWith(
-            ...withVarsVariables
-        );
-        const subqueryClause = Cypher.concat(withStatement, callStatement);
         if (context.subscriptionsEnabled) {
-            const afterCallWithStatement = new Cypher.With("*", [new Cypher.NamedVariable("update_meta"), "meta"]);
-            Cypher.concat(subqueryClause, afterCallWithStatement);
+            subqueryClause.with("*", [new Cypher.NamedVariable("update_meta"), "meta"]);
         }
-
         return subqueryClause;
     });
 
-    const query = Cypher.concat(...wrappedQueries);
-
+    const query = Cypher.utils.concat(...wrappedQueries);
     return query.build(`${varName}_`);
 }
 
@@ -159,14 +154,14 @@ function createConnectOrCreatePartialStatement({
 
     if (authorizationBeforePredicateReturn.predicate) {
         if (authorizationBeforePredicateReturn.preComputedSubqueries) {
-            mergeQuery = Cypher.concat(
+            mergeQuery = Cypher.utils.concat(
                 mergeQuery,
                 new Cypher.With("*"),
                 authorizationBeforePredicateReturn.preComputedSubqueries
             );
         }
 
-        mergeQuery = Cypher.concat(
+        mergeQuery = Cypher.utils.concat(
             mergeQuery,
             new Cypher.With("*").where(authorizationBeforePredicateReturn.predicate)
         );
@@ -184,7 +179,7 @@ function createConnectOrCreatePartialStatement({
         withVars,
     });
 
-    mergeQuery = Cypher.concat(mergeQuery, mergeCypher);
+    mergeQuery = Cypher.utils.concat(mergeQuery, mergeCypher);
 
     const authorizationAfterPredicateReturn = createAuthorizationAfterConnectOrCreate({
         context,
@@ -199,14 +194,14 @@ function createConnectOrCreatePartialStatement({
             authorizationAfterPredicateReturn.preComputedSubqueries &&
             !authorizationAfterPredicateReturn.preComputedSubqueries.empty
         ) {
-            mergeQuery = Cypher.concat(
+            mergeQuery = Cypher.utils.concat(
                 mergeQuery,
                 new Cypher.With(new Cypher.NamedVariable("*")),
                 authorizationAfterPredicateReturn.preComputedSubqueries,
                 new Cypher.With(new Cypher.NamedVariable("*")).where(authorizationAfterPredicateReturn.predicate)
             );
         } else {
-            mergeQuery = Cypher.concat(
+            mergeQuery = Cypher.utils.concat(
                 mergeQuery,
                 new Cypher.With("*").where(authorizationAfterPredicateReturn.predicate)
             );
@@ -273,7 +268,7 @@ function mergeStatement({
         return [node.property(key), param];
     });
 
-    const merge = new Cypher.Merge(nodePattern).onCreate(...onCreateParams, ...callbackParams);
+    const merge = new Cypher.Merge(nodePattern).onCreateSet(...onCreateParams, ...callbackParams);
 
     const relationshipFields = context.relationships.find((x) => x.properties === relationField.properties);
     const autogeneratedRelationshipParams = relationshipFields ? getAutogeneratedParams(relationshipFields) : {};
@@ -317,7 +312,7 @@ function mergeStatement({
         });
     }
 
-    return Cypher.concat(merge, relationshipMerge, withClause);
+    return Cypher.utils.concat(merge, relationshipMerge, withClause);
 }
 
 function createAuthorizationBeforeConnectOrCreate({
@@ -353,7 +348,7 @@ function createAuthorizationBeforeConnectOrCreate({
         }
 
         if (preComputedSubqueries) {
-            subqueries = Cypher.concat(subqueries, preComputedSubqueries);
+            subqueries = Cypher.utils.concat(subqueries, preComputedSubqueries);
         }
     }
 
@@ -409,7 +404,7 @@ function createAuthorizationAfterConnectOrCreate({
         }
 
         if (preComputedSubqueries) {
-            subqueries = Cypher.concat(subqueries, preComputedSubqueries);
+            subqueries = Cypher.utils.concat(subqueries, preComputedSubqueries);
         }
     }
 
@@ -421,7 +416,7 @@ function createAuthorizationAfterConnectOrCreate({
         }
 
         if (preComputedSubqueries) {
-            subqueries = Cypher.concat(subqueries, preComputedSubqueries);
+            subqueries = Cypher.utils.concat(subqueries, preComputedSubqueries);
         }
     }
 

diff --git a/packages/graphql/src/translate/queryAST/ast/QueryAST.ts b/packages/graphql/src/translate/queryAST/ast/QueryAST.ts
@@ -38,7 +38,7 @@ export class QueryAST {
 
     public build(neo4jGraphQLContext: Neo4jGraphQLTranslationContext, varName?: string): Cypher.Clause {
         const context = this.buildQueryASTContext(neo4jGraphQLContext, varName);
-        return Cypher.concat(...this.transpile(context).clauses);
+        return Cypher.utils.concat(...this.transpile(context).clauses);
     }
 
     // TODO: refactor other top level operations to use this method instead of build
@@ -54,7 +54,7 @@ export class QueryAST {
             }
         }
 
-        return Cypher.concat(...clauses, returnClause);
+        return Cypher.utils.concat(...clauses, returnClause);
     }
 
     /**

diff --git a/...graphql/src/translate/queryAST/ast/fields/aggregation-fields/AggregationAttributeField.ts b/...graphql/src/translate/queryAST/ast/fields/aggregation-fields/AggregationAttributeField.ts
@@ -61,12 +61,10 @@ export class AggregationAttributeField extends AggregationField {
 
             const projection = new Cypher.Return([this.createAggregationExpr(listVar), returnVar]);
 
-            return Cypher.concat(
-                new Cypher.With(target)
-                    .orderBy([Cypher.size(aggrProp), "DESC"])
-                    .with([Cypher.collect(aggrProp), listVar]),
-                projection
-            );
+            return new Cypher.With(target)
+                .orderBy([Cypher.size(aggrProp), "DESC"])
+                .with([Cypher.collect(aggrProp), listVar])
+                .return(projection);
         }
 
         return new Cypher.Return([this.getAggregationExpr(target), returnVar]);

diff --git a/packages/graphql/src/translate/queryAST/ast/filters/ConnectionFilter.ts b/packages/graphql/src/translate/queryAST/ast/filters/ConnectionFilter.ts
@@ -224,7 +224,7 @@ export class ConnectionFilter extends Filter {
         const withPredicateReturn = new Cypher.With("*")
             .where(Cypher.and(...innerFiltersPredicates))
             .return([countComparisonPredicate, returnVar]);
-        return [Cypher.concat(match, ...subqueries, withPredicateReturn)];
+        return [Cypher.utils.concat(match, ...subqueries, withPredicateReturn)];
     }
 
     // This method has a big deal of complexity due to a couple of factors:
@@ -278,7 +278,7 @@ export class ConnectionFilter extends Filter {
         const truthyPredicates = truthyFilters.map((v) => Cypher.eq(v, Cypher.true));
         this.subqueryPredicate = Cypher.and(...falsyPredicates, ...truthyPredicates);
 
-        return [Cypher.concat(match, ...subqueries), Cypher.concat(match2, ...subqueries2)];
+        return [Cypher.utils.concat(match, ...subqueries), Cypher.utils.concat(match2, ...subqueries2)];
     }
 
     private wrapInNotIfNeeded(predicate: Cypher.Predicate): Cypher.Predicate {

diff --git a/packages/graphql/src/translate/queryAST/ast/filters/RelationshipFilter.ts b/packages/graphql/src/translate/queryAST/ast/filters/RelationshipFilter.ts
@@ -127,7 +127,7 @@ export class RelationshipFilter extends Filter {
                 }
 
                 withClause.return([returnCondition, countVar]);
-                return Cypher.concat(relationshipMatch, ...selection, withClause);
+                return Cypher.utils.concat(relationshipMatch, ...selection, withClause);
             })
         );
 
@@ -202,7 +202,7 @@ export class RelationshipFilter extends Filter {
 
                 withAfterSubqueries.return([returnPredicate, returnVar]);
 
-                return [Cypher.concat(match, ...nestedSubqueries, withAfterSubqueries)];
+                return [Cypher.utils.concat(match, ...nestedSubqueries, withAfterSubqueries)];
             }
 
             case "ALL": {
@@ -257,9 +257,9 @@ export class RelationshipFilter extends Filter {
             }
             withClause.return([Cypher.gt(Cypher.count(context.target), new Cypher.Literal(0)), returnVar]); // THis variable needs to be used in predicate
 
-            return Cypher.concat(...nestedSubqueries, withClause);
+            return Cypher.utils.concat(...nestedSubqueries, withClause);
         });
-        return { clause: Cypher.concat(match, ...subqueries), returnVariables };
+        return { clause: Cypher.utils.concat(match, ...subqueries), returnVariables };
     }
 
     private getNestedSubqueryFilter(target: Cypher.Expr): Cypher.Predicate {

diff --git a/packages/graphql/src/translate/queryAST/ast/filters/property-filters/CypherFilter.ts b/packages/graphql/src/translate/queryAST/ast/filters/property-filters/CypherFilter.ts
@@ -70,10 +70,7 @@ export class CypherFilter extends Filter {
     public getSubqueries(context: QueryASTContext): Cypher.Clause[] {
         const { selection: cypherSubquery, nestedContext } = this.selection.apply(context);
 
-        const clause = Cypher.concat(
-            cypherSubquery,
-            new Cypher.Return([nestedContext.returnVariable, this.returnVariable])
-        );
+        const clause = cypherSubquery.return([nestedContext.returnVariable, this.returnVariable]);
 
         return [clause];
     }

diff --git a/packages/graphql/src/translate/queryAST/ast/operations/AggregationOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/AggregationOperation.ts
@@ -270,7 +270,7 @@ export class AggregationOperation extends Operation {
             this.addSortToClause(nestedContext, targetVar, sortClause);
         }
 
-        return Cypher.concat(
+        return Cypher.utils.concat(
             matchClause,
             ...selectionClauses,
             ...nestedSubqueries,

diff --git a/packages/graphql/src/translate/queryAST/ast/operations/ConnectionReadOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/ConnectionReadOperation.ts
@@ -182,7 +182,7 @@ export class ConnectionReadOperation extends Operation {
 
         return {
             clauses: [
-                Cypher.concat(
+                Cypher.utils.concat(
                     ...extraMatches,
                     selectionClause,
                     ...filtersSubqueries,
@@ -239,7 +239,7 @@ export class ConnectionReadOperation extends Operation {
         const paginationWith = this.generateSortAndPaginationClause(context);
 
         return new Cypher.Call(
-            Cypher.concat(
+            Cypher.utils.concat(
                 unwindClause,
                 ...prePaginationSubqueries,
                 paginationWith,

diff --git a/packages/graphql/src/translate/queryAST/ast/operations/CreateOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/CreateOperation.ts
@@ -57,7 +57,7 @@ export class CreateOperation extends MutationOperation {
 
     private getProjectionClause(context: QueryASTContext): Cypher.Clause[] {
         return this.projectionOperations.map((operationField) => {
-            return Cypher.concat(...operationField.transpile(context).clauses);
+            return Cypher.utils.concat(...operationField.transpile(context).clauses);
         });
     }
 }
diff --git a/packages/graphql/src/translate/queryAST/ast/operations/CypherOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/CypherOperation.ts
@@ -47,7 +47,7 @@ export class CypherOperation extends ReadOperation {
     public transpile(context: QueryASTContext<Cypher.Node | undefined>): OperationTranspileResult {
         // eslint-disable-next-line prefer-const
         let { selection: matchClause, nestedContext } = this.selection.apply(context);
-        const fieldSubqueries = Cypher.concat(
+        const fieldSubqueries = Cypher.utils.concat(
             ...this.getFieldsSubqueries(nestedContext),
             ...this.getCypherFieldsSubqueries(nestedContext)
         );
@@ -64,7 +64,7 @@ export class CypherOperation extends ReadOperation {
 
         const ret = this.getReturnClause(nestedContext, context.returnVariable);
         const extraMatches: SelectionClause[] = this.getChildren().flatMap((f) => f.getSelection(nestedContext));
-        const clause = Cypher.concat(matchClause, ...extraMatches, fieldSubqueries, ...authClauses, ret);
+        const clause = Cypher.utils.concat(matchClause, ...extraMatches, fieldSubqueries, ...authClauses, ret);
         return {
             clauses: [clause],
             projectionExpr: context.returnVariable,

diff --git a/packages/graphql/src/translate/queryAST/ast/operations/CypherScalarOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/CypherScalarOperation.ts
@@ -52,11 +52,10 @@ export class CypherScalarOperation extends Operation {
         } else {
             retProj = [nestedContext.returnVariable, context.returnVariable];
         }
-        const ret = new Cypher.Return(retProj);
         const scope = context.getTargetScope();
         // by setting the return variable of this operation in the attribute scope, we can avoid duplicate the same cypher resolution for sorting and projection purposes
         scope.set(this.cypherAttributeField.name, context.returnVariable);
-        const clause = Cypher.concat(matchClause, ret);
+        const clause = matchClause.return(retProj);
 
         return {
             clauses: [clause],

diff --git a/packages/graphql/src/translate/queryAST/ast/operations/DeleteOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/DeleteOperation.ts
@@ -93,7 +93,7 @@ export class DeleteOperation extends MutationOperation {
             statements.push(new Cypher.With("*"), ...nestedOperations);
         }
         statements = this.appendDeleteClause(statements, context);
-        const ret = Cypher.concat(...statements);
+        const ret = Cypher.utils.concat(...statements);
 
         return { clauses: [ret], projectionExpr: context.target };
     }
@@ -131,7 +131,7 @@ export class DeleteOperation extends MutationOperation {
             statements.push(new Cypher.With("*"), ...nestedOperations);
         }
         statements.push(withBeforeDeleteBlock, deleteBlock);
-        const ret = Cypher.concat(...statements);
+        const ret = Cypher.utils.concat(...statements);
         return { clauses: [ret], projectionExpr: Cypher.Null };
     }
 

diff --git a/packages/graphql/src/translate/queryAST/ast/operations/ReadOperation.ts b/packages/graphql/src/translate/queryAST/ast/operations/ReadOperation.ts
@@ -159,7 +159,7 @@ export class ReadOperation extends Operation {
         // This weird condition is just for cypher compatibility
         const shouldAddWithForAuth = authFilterSubqueries.length || authFiltersPredicate.length;
         if (filterSubqueries.length || shouldAddWithForAuth) {
-            filterSubqueriesClause = Cypher.concat(...filterSubqueries);
+            filterSubqueriesClause = Cypher.utils.concat(...filterSubqueries);
             if (!isCreateSelection || authFilterSubqueries.length) {
                 filterSubqueryWith = new Cypher.With("*");
             }
@@ -168,26 +168,32 @@ export class ReadOperation extends Operation {
         let sortAndLimitBlock: Cypher.Clause | undefined;
         let subqueries: Cypher.Clause;
         if (this.relationship) {
-            subqueries = Cypher.concat(...fieldSubqueries, ...cypherFieldSubqueries, ...sortSubqueries);
+            subqueries = Cypher.utils.concat(...fieldSubqueries, ...cypherFieldSubqueries, ...sortSubqueries);
         } else {
-            subqueries = Cypher.concat(...fieldSubqueries);
+            subqueries = Cypher.utils.concat(...fieldSubqueries);
 
             let sortClause: Cypher.With | undefined;
             if (this.sortFields.length || this.pagination) {
                 sortClause = new Cypher.With("*");
                 this.addSortToClause(nestedContext, nestedContext.target, sortClause);
             }
-            const sortBlock = Cypher.concat(...sortSubqueries, sortClause);
+            const sortBlock = Cypher.utils.concat(...sortSubqueries, sortClause);
 
             sortAndLimitBlock = this.hasCypherSort()
-                ? Cypher.concat(...cypherFieldSubqueries, sortBlock)
-                : Cypher.concat(sortBlock, ...cypherFieldSubqueries);
+                ? Cypher.utils.concat(...cypherFieldSubqueries, sortBlock)
+                : Cypher.utils.concat(sortBlock, ...cypherFieldSubqueries);
         }
 
         let clause: Cypher.Clause;
         if (isCreateSelection && !this.relationship) {
             // Top-level read part of a mutation does not contain the MATCH clause as it's implicit in the mutation.
-            clause = Cypher.concat(filterSubqueriesClause, filterSubqueryWith, sortAndLimitBlock, subqueries, ret);
+            clause = Cypher.utils.concat(
+                filterSubqueriesClause,
+                filterSubqueryWith,
+                sortAndLimitBlock,
+                subqueries,
+                ret
+            );
         } else {
             const extraMatches: SelectionClause[] = this.getChildren().flatMap((f) => f.getSelection(nestedContext));
             let extraMatchesWith: Cypher.With | undefined;
@@ -209,7 +215,7 @@ export class ReadOperation extends Operation {
             }
             matchBlock.push(...extraMatches, extraMatchesWith);
 
-            clause = Cypher.concat(
+            clause = Cypher.utils.concat(
                 ...matchBlock,
                 ...authFilterSubqueries,
                 filterSubqueriesClause,