Improve db procedures

.changeset/hip-pillows-tap.md

@@ -0,0 +1,5 @@
+---
+"@neo4j/cypher-builder": patch
+---
+
+Adds db.index.fulltext.queryRelationships

src/Cypher.ts

@@ -129,6 +129,7 @@ export type { PredicateFunction } from "./expressions/functions/PredicateFunctio
 export type { Order } from "./clauses/sub-clauses/OrderBy";
 export type { CompositeClause } from "./clauses/utils/concat";
 export type { CypherAggregationFunction as AggregationFunction } from "./expressions/functions/AggregationFunctions";
+export { InputArgument } from "./utils/normalize-variable";
 
 // utils
 export * as utils from "./utils/utils";

src/procedures/db.test.ts

@@ -34,10 +34,10 @@ describe("db procedures", () => {
                 `"CALL db.index.fulltext.queryNodes(\\"my-text-index\\", $param0) YIELD node AS this0"`
             );
             expect(params).toMatchInlineSnapshot(`
-{
-  "param0": "This is a lovely phrase",
-}
-`);
+                {
+                  "param0": "This is a lovely phrase",
+                }
+            `);
         });
 
         test("Fulltext with where and return", () => {
@@ -56,11 +56,102 @@ describe("db procedures", () => {
                 RETURN this0"
             `);
             expect(params).toMatchInlineSnapshot(`
-{
-  "param0": "This is a lovely phrase",
-  "param1": "The Matrix",
-}
-`);
+                {
+                  "param0": "This is a lovely phrase",
+                  "param1": "The Matrix",
+                }
+            `);
+        });
+
+        test("Fulltext with options", () => {
+            const fulltextProcedure = Cypher.db.index.fulltext.queryNodes(
+                "my-text-index",
+                new Param("This is a lovely phrase"),
+                {
+                    skip: 5,
+                    analyser: new Param("whitespace"),
+                }
+            );
+
+            const { cypher, params } = fulltextProcedure.build();
+
+            expect(cypher).toMatchInlineSnapshot(
+                `"CALL db.index.fulltext.queryNodes(\\"my-text-index\\", $param0, { skip: 5, analyser: $param1 })"`
+            );
+            expect(params).toMatchInlineSnapshot(`
+                {
+                  "param0": "This is a lovely phrase",
+                  "param1": "whitespace",
+                }
+            `);
+        });
+    });
+    describe("db.index.fulltext.queryRelationships", () => {
+        test("Simple fulltext", () => {
+            const targetNode = new Cypher.Node({ labels: ["Movie"] });
+            const fulltextProcedure = Cypher.db.index.fulltext
+                .queryRelationships("my-text-index", new Param("This is a lovely phrase"))
+                .yield(["relationship", targetNode]);
+
+            const { cypher, params } = fulltextProcedure.build();
+
+            expect(cypher).toMatchInlineSnapshot(
+                `"CALL db.index.fulltext.queryRelationships(\\"my-text-index\\", $param0) YIELD relationship AS this0"`
+            );
+            expect(params).toMatchInlineSnapshot(`
+                {
+                  "param0": "This is a lovely phrase",
+                }
+            `);
+        });
+
+        test("Fulltext with options", () => {
+            const fulltextProcedure = Cypher.db.index.fulltext.queryRelationships(
+                "my-text-index",
+                new Param("This is a lovely phrase"),
+                {
+                    skip: 5,
+                    analyser: new Param("whitespace"),
+                }
+            );
+
+            const { cypher, params } = fulltextProcedure.build();
+
+            expect(cypher).toMatchInlineSnapshot(
+                `"CALL db.index.fulltext.queryRelationships(\\"my-text-index\\", $param0, { skip: 5, analyser: $param1 })"`
+            );
+            expect(params).toMatchInlineSnapshot(`
+                {
+                  "param0": "This is a lovely phrase",
+                  "param1": "whitespace",
+                }
+            `);
+        });
+    });
+
+    describe("db.labels", () => {
+        it("dbLabels", () => {
+            const dbLabels = Cypher.db.labels();
+            const { cypher, params } = dbLabels.build();
+
+            expect(cypher).toMatchInlineSnapshot(`"CALL db.labels()"`);
+            expect(params).toMatchInlineSnapshot(`{}`);
+        });
+
+        it("dbLabels with yield *", () => {
+            const dbLabels = Cypher.db.labels().yield("*");
+            const { cypher, params } = dbLabels.build();
+
+            expect(cypher).toMatchInlineSnapshot(`"CALL db.labels() YIELD *"`);
+            expect(params).toMatchInlineSnapshot(`{}`);
+        });
+
+        it("dbLabels with yield ", () => {
+            const dbLabels = Cypher.db.labels().yield("label");
+            const { cypher, params } = dbLabels.build();
+
+            expect(cypher).toMatchInlineSnapshot(`"CALL db.labels() YIELD label"`);
+            expect(params).toMatchInlineSnapshot(`{}`);
         });
     });
 });

src/procedures/db.ts

@@ -18,10 +18,11 @@
  */
 
 import { CypherProcedure } from "./CypherProcedure";
-import type { Literal } from "../references/Literal";
+import { Literal } from "../references/Literal";
 import type { Param } from "../references/Param";
 import type { Variable } from "../references/Variable";
-import { normalizeVariable } from "../utils/normalize-variable";
+import { InputArgument, normalizeMap, normalizeVariable } from "../utils/normalize-variable";
+import { Expr } from "../types";
 
 type FulltextPhrase = string | Literal<string> | Param | Variable;
 
@@ -32,12 +33,37 @@ type FulltextPhrase = string | Literal<string> | Param | Variable;
  */
 export const index = {
     fulltext: {
-        queryNodes(indexName: string | Literal<string>, phrase: FulltextPhrase): CypherProcedure<"node" | "score"> {
-            // TODO: add options, skip limit, analyzer
-            const phraseVar = normalizeVariable(phrase);
+        queryNodes(
+            indexName: string | Literal<string>,
+            queryString: FulltextPhrase,
+            options?: { skip?: InputArgument<number>; limit?: InputArgument<number>; analyser?: InputArgument<string> }
+        ): CypherProcedure<"node" | "score"> {
+            const phraseVar = normalizeVariable(queryString);
             const indexNameVar = normalizeVariable(indexName);
 
-            return new CypherProcedure("db.index.fulltext.queryNodes", [indexNameVar, phraseVar]);
+            const procedureArgs: Expr[] = [indexNameVar, phraseVar];
+            if (options) {
+                const optionsMap = normalizeMap(options);
+                procedureArgs.push(optionsMap);
+            }
+
+            return new CypherProcedure("db.index.fulltext.queryNodes", procedureArgs);
+        },
+        queryRelationships(
+            indexName: string | Literal<string>,
+            queryString: FulltextPhrase,
+            options?: { skip?: InputArgument<number>; limit?: InputArgument<number>; analyser?: InputArgument<string> }
+        ): CypherProcedure<"relationship" | "score"> {
+            const phraseVar = normalizeVariable(queryString);
+            const indexNameVar = normalizeVariable(indexName);
+
+            const procedureArgs: Expr[] = [indexNameVar, phraseVar];
+            if (options) {
+                const optionsMap = normalizeMap(options);
+                procedureArgs.push(optionsMap);
+            }
+
+            return new CypherProcedure("db.index.fulltext.queryRelationships", procedureArgs);
         },
     },
 };

src/utils/normalize-variable.ts

@@ -21,8 +21,20 @@ import { Literal } from "../references/Literal";
 import { isCypherCompilable } from "./is-cypher-compilable";
 import type { Param } from "../references/Param";
 import type { Variable } from "../references/Variable";
+import { MapExpr } from "../expressions/map/MapExpr";
 
-export function normalizeVariable(value: string | number | Variable | Literal | Param): Variable | Literal | Param {
+type VariableInput = string | number | Variable | Literal | Param;
+
+export type InputArgument<T extends string | number> = T | Variable | Literal<T> | Param<T>;
+
+export function normalizeVariable(value: VariableInput): Variable | Literal | Param {
     if (isCypherCompilable(value)) return value;
     return new Literal(value);
 }
+
+export function normalizeMap(map: Record<string, VariableInput>): MapExpr {
+    return Object.entries(map).reduce((mapExpr, [key, value]) => {
+        mapExpr.set(key, normalizeVariable(value));
+        return mapExpr;
+    }, new MapExpr());
+}