[WIP] Update translation layer

packages/graphql/package.json

@@ -81,7 +81,7 @@
         "@graphql-tools/resolvers-composition": "^7.0.0",
         "@graphql-tools/schema": "^10.0.0",
         "@graphql-tools/utils": "10.9.1",
-        "@neo4j/cypher-builder": "2.8.1",
+        "@neo4j/cypher-builder": "2.10.0",
         "camelcase": "^6.3.0",
         "debug": "^4.3.4",
         "dot-prop": "^6.0.1",

packages/graphql/src/classes/GraphElement.ts

@@ -18,14 +18,14 @@
  */
 
 import type {
-    CypherField,
-    PrimitiveField,
+    BaseField,
     CustomEnumField,
+    CustomResolverField,
     CustomScalarField,
-    TemporalField,
+    CypherField,
     PointField,
-    CustomResolverField,
-    BaseField,
+    PrimitiveField,
+    TemporalField,
 } from "../types";
 
 export interface GraphElementConstructor {
@@ -40,6 +40,7 @@ export interface GraphElementConstructor {
     customResolverFields: CustomResolverField[];
 }
 
+/** @deprecated */
 export abstract class GraphElement {
     public name: string;
     public description?: string;

packages/graphql/src/classes/Node.ts

@@ -109,6 +109,7 @@ export type SubscriptionEvents = {
     delete_relationship: string;
 };
 
+/** @deprecated */
 class Node extends GraphElement {
     public relationFields: RelationField[];
     public connectionFields: ConnectionField[];

packages/graphql/src/classes/Relationship.ts

@@ -45,7 +45,7 @@ interface RelationshipConstructor {
     pointFields?: PointField[];
     customResolverFields?: CustomResolverField[];
 }
-
+/** @deprecated */
 class Relationship extends GraphElement {
     public properties?: string;
     public source: string;

packages/graphql/src/schema/resolvers/mutation/update.ts

@@ -29,6 +29,7 @@ import type { Neo4jGraphQLTranslationContext } from "../../../types/neo4j-graphq
 import { execute } from "../../../utils";
 import getNeo4jResolveTree from "../../../utils/get-neo4j-resolve-tree";
 import type { Neo4jGraphQLComposedContext } from "../composition/wrap-query-and-mutation";
+import { translateUpdate2 } from "../../../translate/translate-update";
 
 export function updateResolver({
     node,
@@ -42,7 +43,8 @@ export function updateResolver({
 
         (context as Neo4jGraphQLTranslationContext).resolveTree = resolveTree;
 
-        const [cypher, params] = await translateUpdate({ context: context as Neo4jGraphQLTranslationContext, node });
+        // const [cypher, params] = await translateUpdate({ context: context as Neo4jGraphQLTranslationContext, node });
+        const { cypher, params } = await translateUpdate2({ context: context as Neo4jGraphQLTranslationContext, node });
         const executeResult = await execute({
             cypher,
             params,
@@ -64,7 +66,8 @@ export function updateResolver({
 
         if (nodeProjection) {
             const nodeKey = nodeProjection.alias ? nodeProjection.alias.value : nodeProjection.name.value;
-            resolveResult[nodeKey] = executeResult.records[0]?.data || [];
+            // resolveResult[nodeKey] = executeResult.records[0]?.data || [];
+            resolveResult[nodeKey] = executeResult.records.map((x) => x.this);
         }
 
         return resolveResult;

packages/graphql/src/translate/queryAST/ast/QueryAST.ts

@@ -27,6 +27,7 @@ import { ConnectionReadOperation } from "./operations/ConnectionReadOperation";
 import { DeleteOperation } from "./operations/DeleteOperation";
 import { ReadOperation } from "./operations/ReadOperation";
 import { TopLevelCreateMutationOperation } from "./operations/TopLevelCreateMutationOperation";
+import { TopLevelUpdateMutationOperation } from "./operations/TopLevelUpdateMutationOperation";
 import { UnwindCreateOperation } from "./operations/UnwindCreateOperation";
 import type { Operation, OperationTranspileResult } from "./operations/operations";
 
@@ -87,7 +88,8 @@ export class QueryAST {
             this.operation instanceof DeleteOperation ||
             this.operation instanceof AggregationOperation ||
             this.operation instanceof UnwindCreateOperation ||
-            this.operation instanceof TopLevelCreateMutationOperation
+            this.operation instanceof TopLevelCreateMutationOperation ||
+            this.operation instanceof TopLevelUpdateMutationOperation
         ) {
             return createNode(varName);
         }
@@ -105,7 +107,7 @@ function getTreeLines(treeNode: QueryASTNode, depth: number = 0): string[] {
 
     const line = "────";
     if (depth === 0) {
-        resultLines.push(`${nodeName}`);
+        resultLines.push(getTopLevelNodeName(nodeName));
     } else if (depth === 1) {
         resultLines.push(`|${line} ${nodeName}`);
     } else {
@@ -129,3 +131,19 @@ function getTreeLines(treeNode: QueryASTNode, depth: number = 0): string[] {
 
     return resultLines;
 }
+
+function getTopLevelNodeName(nodeName: string): string {
+    const currentMonth = new Date().getMonth();
+    const isApril = currentMonth === 3;
+    const isOctober = currentMonth === 9;
+    const isDecember = currentMonth === 11;
+    if (isOctober) {
+        return `${nodeName} \u{1F383}\u{1F383}\u{1F383}`;
+    } else if (isDecember) {
+        return `${nodeName} \u{1F384}\u{1F384}\u{1F384}`;
+    } else if (isApril) {
+        return `${nodeName} \u{1F430}\u{1F430}\u{1F430}`;
+    } else {
+        return `${nodeName}`;
+    }
+}

packages/graphql/src/translate/queryAST/ast/input-fields/IdField.ts

@@ -33,10 +33,6 @@ export class IdField extends InputField {
         return [];
     }
 
-    public print(): string {
-        return `${super.print()} <${this.name}>`;
-    }
-
     public getSetParams(queryASTContext: QueryASTContext<Cypher.Node>): Cypher.SetParam[] {
         const target = this.getTarget(queryASTContext);
         const setParam: Cypher.SetParam = [target.property(this.attribute.databaseName), Cypher.randomUUID()];

packages/graphql/src/translate/queryAST/ast/input-fields/InputField.ts

@@ -39,6 +39,9 @@ export abstract class InputField extends QueryASTNode {
         return [];
     }
 
+    public getPredicate(_queryASTContext: QueryASTContext): Cypher.Predicate | undefined {
+        return undefined;
+    }
     protected getTarget(queryASTContext: QueryASTContext<Cypher.Node>): Cypher.Node | Cypher.Relationship {
         const target = this.attachedTo === "node" ? queryASTContext.target : queryASTContext.relationship;
         if (!target) {

packages/graphql/src/translate/queryAST/ast/input-fields/ParamInputField.ts

@@ -37,6 +37,8 @@ export class ParamInputField extends InputField {
     protected attribute: AttributeAdapter;
     protected inputValue: unknown;
 
+    private memoizedParam: Cypher.Param | undefined;
+
     constructor({
         attribute,
         attachedTo,
@@ -59,23 +61,43 @@ export class ParamInputField extends InputField {
         queryASTContext: QueryASTContext<Cypher.Node>,
         _inputVariable?: Cypher.Variable
     ): Cypher.SetParam[] {
-        const target = this.getTarget(queryASTContext);
+        // This check is needed for populatedBy callbacks
+        const param = this.getParam();
+        if (param instanceof Cypher.Param) {
+            if (param.value === undefined) {
+                return [];
+            }
+        }
+        const leftExpr = this.getLeftExpression(queryASTContext);
+        const rightExpr = this.getRightExpression(queryASTContext);
+
+        const setField: Cypher.SetParam = [leftExpr, rightExpr];
+        return [setField];
+    }
+
+    protected getLeftExpression(queryASTContext: QueryASTContext<Cypher.Node>): Cypher.Property {
+        return this.getTarget(queryASTContext).property(this.attribute.databaseName);
+    }
 
-        let rightVariable: Cypher.Expr;
+    protected getParam(): Cypher.Variable {
         if (this.inputValue instanceof Cypher.Variable) {
-            rightVariable = this.inputValue;
+            return this.inputValue;
         } else {
-            rightVariable = new Cypher.Param(this.inputValue);
+            if (!this.memoizedParam) {
+                this.memoizedParam = new Cypher.Param(this.inputValue);
+            }
+            return this.memoizedParam;
         }
+    }
 
-        const leftExpr = target.property(this.attribute.databaseName);
-        const rightExpr = this.coerceReference(rightVariable);
-
-        const setField: Cypher.SetParam = [leftExpr, rightExpr];
-        return [setField];
+    protected getRightExpression(
+        _: QueryASTContext<Cypher.Node>
+    ): Exclude<Cypher.Expr, Cypher.Map | Cypher.MapProjection> {
+        const rightVariable = this.getParam();
+        return this.coerceReference(rightVariable);
     }
 
-    private coerceReference(
+    protected coerceReference(
         variable: Cypher.Variable | Cypher.Property
     ): Exclude<Cypher.Expr, Cypher.Map | Cypher.MapProjection> {
         if (this.attribute.typeHelper.isSpatial()) {
@@ -104,7 +126,6 @@ export class ParamInputField extends InputField {
             const mapTime = Cypher.time(comprehensionVar);
             return new Cypher.ListComprehension(comprehensionVar, variable).map(mapTime);
         }
-
         return variable;
     }
 }

packages/graphql/src/translate/queryAST/ast/input-fields/operators/MathInputField.ts

@@ -0,0 +1,102 @@
+/*
+ * 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.
+ */
+
+import Cypher from "@neo4j/cypher-builder";
+import type { AttributeAdapter } from "../../../../../schema-model/attribute/model-adapters/AttributeAdapter";
+import { type QueryASTContext } from "../../QueryASTContext";
+import { ParamInputField } from "../ParamInputField";
+
+type MathOperator = "increment" | "decrement" | "add" | "subtract" | "divide" | "multiply";
+
+export class MathInputField extends ParamInputField {
+    private operation: MathOperator;
+
+    constructor({
+        attribute,
+        attachedTo,
+        inputValue,
+        operation,
+    }: {
+        attribute: AttributeAdapter;
+        attachedTo: "node" | "relationship";
+        inputValue: unknown;
+        operation: MathOperator;
+    }) {
+        super({ attribute, attachedTo, inputValue });
+        this.operation = operation;
+        if (operation == "divide" && inputValue === 0) {
+            throw new Error("Division by zero is not supported");
+        }
+    }
+
+    public getChildren() {
+        return [];
+    }
+
+    public getSubqueries(queryASTContext: QueryASTContext<Cypher.Node>): Cypher.Clause[] {
+        const prop = this.getLeftExpression(queryASTContext);
+
+        const bitSize = this.attribute.typeHelper.isInt() ? 32 : 64;
+        const rightExpr = this.getRightExpression(queryASTContext);
+        // Avoid overflows, for 64 bit overflows, a long overflow is raised anyway by Neo4j
+
+        const maxBit = Cypher.minus(
+            Cypher.pow(new Cypher.Literal(2), new Cypher.Literal(bitSize - 1)),
+            new Cypher.Literal(1)
+        );
+
+        return [
+            Cypher.utils.concat(
+                Cypher.apoc.util.validate(
+                    Cypher.isNull(prop),
+                    "Cannot %s %s to Nan",
+                    new Cypher.List([new Cypher.Literal(this.operation), this.getParam()])
+                ),
+                Cypher.apoc.util.validate(
+                    Cypher.gt(rightExpr, maxBit),
+                    "Overflow: Value returned from operator %s is larger than %s bit",
+                    new Cypher.List([new Cypher.Literal(this.operation), new Cypher.Literal(bitSize)])
+                )
+            ),
+        ];
+    }
+
+    protected getRightExpression(
+        queryASTContext: QueryASTContext<Cypher.Node>
+    ): Exclude<Cypher.Expr, Cypher.Map | Cypher.MapProjection> {
+        const rightVariable = super.getRightExpression(queryASTContext);
+        const targetProperty = this.getLeftExpression(queryASTContext);
+
+        switch (this.operation) {
+            case "add":
+            case "increment":
+                return Cypher.plus(targetProperty, rightVariable);
+            case "decrement":
+            case "subtract":
+                return Cypher.minus(targetProperty, rightVariable);
+            case "divide":
+                return Cypher.divide(targetProperty, rightVariable);
+            case "multiply":
+                return Cypher.multiply(targetProperty, rightVariable);
+
+            default:
+                throw new Error(`Unknown operation ${this.operation}`);
+        }
+    }
+}

packages/graphql/src/translate/queryAST/ast/input-fields/operators/PopInputField.ts

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+import Cypher from "@neo4j/cypher-builder";
+import type { AttributeAdapter } from "../../../../../schema-model/attribute/model-adapters/AttributeAdapter";
+import { type QueryASTContext } from "../../QueryASTContext";
+import { ParamInputField } from "../ParamInputField";
+
+export class PopInputField extends ParamInputField {
+    constructor({
+        attribute,
+        attachedTo,
+        inputValue,
+    }: {
+        attribute: AttributeAdapter;
+        attachedTo: "node" | "relationship";
+        inputValue: unknown;
+    }) {
+        super({ attribute, attachedTo, inputValue });
+    }
+
+    public getChildren() {
+        return [];
+    }
+
+    protected getRightExpression(
+        queryASTContext: QueryASTContext<Cypher.Node>
+    ): Exclude<Cypher.Expr, Cypher.Map | Cypher.MapProjection> {
+        const rightVariable = super.getParam();
+        const rightExpr = Cypher.minus(rightVariable);
+        const leftExpr = this.getLeftExpression(queryASTContext);
+        return new Cypher.Raw((context) => {
+            const leftExprCompiled = context.compile(leftExpr);
+            const poppedValueCompiled = context.compile(rightExpr);
+            return `${leftExprCompiled}[0..${poppedValueCompiled}]`;
+        });
+    }
+}