Merge pull request #597 from neo4j/code-cleanup

angrykoala · web-flow · commit e04fefb5955a · 2025-10-22T13:50:26.000+01:00
Apply sonarcloud recommendations
diff --git a/src/Environment.ts b/src/Environment.ts
@@ -81,9 +81,9 @@ export class CypherEnvironment {
     }
 
     public addExtraParams(params: Record<string, Param>): void {
-        Object.entries(params).forEach(([key, param]) => {
+        for (const [key, param] of Object.entries(params)) {
             this.addNamedParamReference(key, param);
-        });
+        }
     }
 
     public addNamedParamReference(name: string, param: Param): void {
diff --git a/src/clauses/mixins/sub-clauses/WithSetRemove.ts b/src/clauses/mixins/sub-clauses/WithSetRemove.ts
@@ -78,6 +78,6 @@ export abstract class WithSetRemove extends Mixin {
             return undefined;
         }
 
-        return this.subClauses[this.subClauses.length - 1];
+        return this.subClauses.at(-1);
     }
 }
diff --git a/src/clauses/mixins/sub-clauses/WithWhere.ts b/src/clauses/mixins/sub-clauses/WithWhere.ts
@@ -31,6 +31,9 @@ import { Mixin } from "../Mixin";
 /** @inline */
 type VariableLike = Variable | Literal | PropertyRef;
 
+/** @inline */
+type WhereInputOrTarget = Predicate | Variable | PropertyRef | undefined;
+
 export abstract class WithWhere extends Mixin {
     protected whereSubClause: Where | undefined;
 
@@ -39,25 +42,22 @@ export abstract class WithWhere extends Mixin {
      */
     public where(input: Predicate | undefined): this;
     public where(target: Variable | PropertyRef, params: Record<string, VariableLike>): this;
-    public where(input: Predicate | Variable | PropertyRef | undefined, params?: Record<string, VariableLike>): this {
-        this.updateOrCreateWhereClause(input, params);
+    public where(inputOrTarget: WhereInputOrTarget, params?: Record<string, VariableLike>): this {
+        this.updateOrCreateWhereClause(inputOrTarget, params);
         return this;
     }
 
     /** Shorthand for `AND` operation after a `WHERE` subclause
      */
     public and(input: Predicate | undefined): this;
     public and(target: Variable | PropertyRef, params: Record<string, VariableLike>): this;
-    public and(input: Predicate | Variable | PropertyRef | undefined, params?: Record<string, VariableLike>): this {
-        this.updateOrCreateWhereClause(input, params);
+    public and(inputOrTarget: WhereInputOrTarget, params?: Record<string, VariableLike>): this {
+        this.updateOrCreateWhereClause(inputOrTarget, params);
         return this;
     }
 
-    private updateOrCreateWhereClause(
-        input: Predicate | Variable | PropertyRef | undefined,
-        params?: Record<string, VariableLike>
-    ): void {
-        const whereInput = this.createWhereInput(input, params);
+    private updateOrCreateWhereClause(inputOrTarget: WhereInputOrTarget, params?: Record<string, VariableLike>): void {
+        const whereInput = this.createWhereInput(inputOrTarget, params);
         if (!whereInput) {
             return;
         }
@@ -71,17 +71,17 @@ export abstract class WithWhere extends Mixin {
     }
 
     private createWhereInput(
-        input: Predicate | Variable | PropertyRef | undefined,
+        inputOrTarget: WhereInputOrTarget,
         params: Record<string, VariableLike> | undefined
     ): Predicate | undefined {
-        if (!input) {
+        if (!inputOrTarget) {
             return undefined;
         }
-        if (input instanceof Variable || input instanceof PropertyRef) {
-            const generatedOp = this.variableAndObjectToOperation(input, params ?? {});
+        if (inputOrTarget instanceof Variable || inputOrTarget instanceof PropertyRef) {
+            const generatedOp = this.variableAndObjectToOperation(inputOrTarget, params ?? {});
             return generatedOp;
         }
-        return input;
+        return inputOrTarget;
     }
 
     /** Transforms a simple input into an operation sub tree */
diff --git a/src/clauses/utils/mixin.ts b/src/clauses/utils/mixin.ts
@@ -46,8 +46,8 @@ export function mixin(...mixins: AbstractConstructorType<any>[]) {
  * Based on https://www.typescriptlang.org/docs/handbook/mixins.html
  */
 function applyMixins<T>(baseClass: ConstructorType<T>, mixins: AbstractConstructorType<unknown>[]): ConstructorType<T> {
-    mixins.forEach((baseCtor) => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+    for (const baseCtor of mixins) {
+        for (const name of Object.getOwnPropertyNames(baseCtor.prototype)) {
             if (name !== "constructor") {
                 // Base class constructor takes precedence over mixins
                 Object.defineProperty(
@@ -57,8 +57,8 @@ function applyMixins<T>(baseClass: ConstructorType<T>, mixins: AbstractConstruct
                     Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ?? Object.create(null)
                 );
             }
-        });
-    });
+        }
+    }
 
     return baseClass;
 }
diff --git a/src/expressions/operations/comparison.test.ts b/src/expressions/operations/comparison.test.ts
@@ -56,7 +56,7 @@ describe("comparison operations", () => {
 
     describe("IS NORMALIZED", () => {
         test("isNormalized (IS NORMALIZED) operator", () => {
-            const stringLiteral = new Cypher.Literal("the \\u212B char");
+            const stringLiteral = new Cypher.Literal(String.raw`the \u212B char`);
             const query = new Cypher.Return([Cypher.isNormalized(stringLiteral), "normalized"]);
             const { cypher } = query.build();
             expect(cypher).toMatchInlineSnapshot(`"RETURN \\"the \\\\u212B char\\" IS NORMALIZED AS normalized"`);
@@ -65,15 +65,15 @@ describe("comparison operations", () => {
         test.each(["NFC", "NFD", "NFKC", "NFKD"] as const)(
             "isNormalized (IS NORMALIZED) operator with normalization type %s",
             (type) => {
-                const stringLiteral = new Cypher.Literal("the \\u212B char");
+                const stringLiteral = new Cypher.Literal(String.raw`the \u212B char`);
                 const query = new Cypher.Return([Cypher.isNormalized(stringLiteral, type), "normalized"]);
                 const { cypher } = query.build();
                 expect(cypher).toBe(`RETURN "the \\u212B char" IS ${type} NORMALIZED AS normalized`);
             }
         );
 
         test("isNotNormalized (IS NOT NORMALIZED) operator with one predicate", () => {
-            const stringLiteral = new Cypher.Literal("the \\u212B char");
+            const stringLiteral = new Cypher.Literal(String.raw`the \u212B char`);
             const query = new Cypher.Return([Cypher.isNotNormalized(stringLiteral), "notNormalized"]);
             const { cypher } = query.build();
             expect(cypher).toMatchInlineSnapshot(
@@ -84,7 +84,7 @@ describe("comparison operations", () => {
         test.each(["NFC", "NFD", "NFKC", "NFKD"] as const)(
             "isNotNormalized (IS NOT NORMALIZED) operator with normalization type %s",
             (type) => {
-                const stringLiteral = new Cypher.Literal("the \\u212B char");
+                const stringLiteral = new Cypher.Literal(String.raw`the \u212B char`);
                 const query = new Cypher.Return([Cypher.isNotNormalized(stringLiteral, type), "notNormalized"]);
                 const { cypher } = query.build();
                 expect(cypher).toBe(`RETURN "the \\u212B char" IS NOT ${type} NORMALIZED AS notNormalized`);
diff --git a/src/utils/escape.ts b/src/utils/escape.ts
@@ -20,7 +20,7 @@
 const ESCAPE_SYMBOL_REGEX = /`/g;
 
 /** These names must be escaped for variables */
-const RESERVED_VAR_NAMES = ["contains", "in", "where", "is"];
+const RESERVED_VAR_NAMES = new Set(["contains", "in", "where", "is"]);
 
 /** Escapes a Node label string */
 export function escapeLabel(label: string): string {
@@ -40,7 +40,7 @@ export function escapeProperty(propName: string): string {
 
 /** Escapes a variable name if needed */
 export function escapeVariable(varName: string): string {
-    if (RESERVED_VAR_NAMES.includes(varName.toLowerCase())) {
+    if (RESERVED_VAR_NAMES.has(varName.toLowerCase())) {
         return escapeString(varName);
     }
     return escapeIfNeeded(varName);
@@ -61,7 +61,7 @@ function escapeIfNeeded(str: string): string {
 
 function escapeString(str: string): string {
     const normalizedStr = normalizeString(str);
-    const escapedStr = normalizedStr.replace(ESCAPE_SYMBOL_REGEX, "``");
+    const escapedStr = normalizedStr.replaceAll(ESCAPE_SYMBOL_REGEX, "``");
     return `\`${escapedStr}\``;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -81,9 +81,9 @@ export class CypherEnvironment {`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public addExtraParams(params: Record<string, Param>): void {`
`84`		`- Object.entries(params).forEach(([key, param]) => {`
	`84`	`+ for (const [key, param] of Object.entries(params)) {`
`85`	`85`	`this.addNamedParamReference(key, param);`
`86`		`- });`
	`86`	`+ }`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`public addNamedParamReference(name: string, param: Param): void {`
Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,6 @@ export abstract class WithSetRemove extends Mixin {`
`78`	`78`	`return undefined;`
`79`	`79`	`}`
`80`	`80`
`81`		`- return this.subClauses[this.subClauses.length - 1];`
	`81`	`+ return this.subClauses.at(-1);`
`82`	`82`	`}`
`83`	`83`	`}`