Merge pull request #600 from neo4j/set-remove-in-with

Add support for set and remove after with

Author: angrykoala

.changeset/rare-mails-swim.md

@@ -0,0 +1,5 @@
+---
+"@neo4j/cypher-builder": minor
+---
+
+Add support for `.set` and `.remove` in Cypher.With

src/clauses/With.test.ts

@@ -317,4 +317,65 @@ RETURN this1"
             expect(params).toMatchInlineSnapshot(`{}`);
         });
     });
+
+    describe("With update", () => {
+        test("Match and update movie", () => {
+            const nameParam = new Cypher.Param("Keanu Reeves");
+            const evilKeanu = new Cypher.Param("Seveer unaeK");
+
+            const personNode = new Cypher.Node();
+
+            const withQuery = new Cypher.Match(new Cypher.Pattern(personNode, { labels: ["Person"] }))
+                .with(personNode)
+                .where(personNode, { name: nameParam })
+                .set([personNode.property("name"), evilKeanu])
+                .return(personNode);
+
+            const queryResult = withQuery.build();
+            expect(queryResult.cypher).toMatchInlineSnapshot(`
+"MATCH (this0:Person)
+WITH this0
+WHERE this0.name = $param0
+SET
+    this0.name = $param1
+RETURN this0"
+`);
+
+            expect(queryResult.params).toMatchInlineSnapshot(`
+{
+  "param0": "Keanu Reeves",
+  "param1": "Seveer unaeK",
+}
+`);
+        });
+
+        test("Match with remove", () => {
+            const idParam = new Cypher.Param("my-id");
+            const nameParam = new Cypher.Param("my-name");
+
+            const movieNode = new Cypher.Node();
+
+            const matchQuery = new Cypher.Match(new Cypher.Pattern(movieNode, { labels: ["Movie"] }))
+                .with("*")
+                .where(movieNode, { id: idParam, name: nameParam })
+                .remove(movieNode.property("name"))
+                .return(movieNode.property("id"));
+
+            const queryResult = matchQuery.build();
+            expect(queryResult.cypher).toMatchInlineSnapshot(`
+"MATCH (this0:Movie)
+WITH *
+WHERE (this0.id = $param0 AND this0.name = $param1)
+REMOVE this0.name
+RETURN this0.id"
+`);
+
+            expect(queryResult.params).toMatchInlineSnapshot(`
+                    {
+                      "param0": "my-id",
+                      "param1": "my-name",
+                    }
+                `);
+        });
+    });
 });

src/clauses/With.ts

@@ -32,6 +32,7 @@ import { WithReturn } from "./mixins/clauses/WithReturn";
 import { WithUnwind } from "./mixins/clauses/WithUnwind";
 import { WithDelete } from "./mixins/sub-clauses/WithDelete";
 import { WithOrder } from "./mixins/sub-clauses/WithOrder";
+import { WithSetRemove } from "./mixins/sub-clauses/WithSetRemove";
 import { WithWhere } from "./mixins/sub-clauses/WithWhere";
 import { Projection } from "./sub-clauses/Projection";
 import { mixin } from "./utils/mixin";
@@ -44,6 +45,7 @@ export interface With
     extends WithOrder,
         WithReturn,
         WithWhere,
+        WithSetRemove,
         WithDelete,
         WithMatch,
         WithUnwind,
@@ -60,6 +62,7 @@ export interface With
     WithOrder,
     WithReturn,
     WithWhere,
+    WithSetRemove,
     WithDelete,
     WithMatch,
     WithUnwind,
@@ -106,12 +109,13 @@ export class With extends Clause {
         const orderByStr = compileCypherIfExists(this.orderByStatement, env, { prefix: "\n" });
         const withStr = compileCypherIfExists(this.withStatement, env, { prefix: "\n" });
         const whereStr = compileCypherIfExists(this.whereSubClause, env, { prefix: "\n" });
+        const setCypher = this.compileSetCypher(env);
         const deleteStr = compileCypherIfExists(this.deleteClause, env, { prefix: "\n" });
         const distinctStr = this.isDistinct ? " DISTINCT" : "";
 
         const nextClause = this.compileNextClause(env);
 
-        return `WITH${distinctStr} ${projectionStr}${whereStr}${orderByStr}${deleteStr}${withStr}${nextClause}`;
+        return `WITH${distinctStr} ${projectionStr}${whereStr}${setCypher}${orderByStr}${deleteStr}${withStr}${nextClause}`;
     }
 
     private getWithClause(clauseOrColumn: With | "*" | WithProjection, columns: Array<"*" | WithProjection>): With {

tests/clause-chaining.test.ts

@@ -188,6 +188,8 @@ describe("Clause chaining", () => {
             "delete",
             "detachDelete",
             "with",
+            "set",
+            "remove",
             "unwind",
             "match",
             "optionalMatch",