flowquery 1.0.34 → 1.0.36

package/src/parsing/functions/id.ts

@@ -0,0 +1,51 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description:
+        "Returns the id of a node or relationship. For nodes, returns the id property. For relationships, returns the type.",
+    category: "scalar",
+    parameters: [
+        {
+            name: "entity",
+            description: "A node or relationship to get the id from",
+            type: "object",
+        },
+    ],
+    output: {
+        description: "The id of the entity",
+        type: "any",
+        example: "1",
+    },
+    examples: ["MATCH (n:Person) RETURN id(n)", "MATCH (a)-[r]->(b) RETURN id(r)"],
+})
+class Id extends Function {
+    constructor() {
+        super("id");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const obj = this.getChildren()[0].value();
+        if (obj === null || obj === undefined) {
+            return null;
+        }
+        if (typeof obj !== "object" || Array.isArray(obj)) {
+            throw new Error("id() expects a node or relationship");
+        }
+
+        // If it's a RelationshipMatchRecord (has type, startNode, endNode, properties)
+        if ("type" in obj && "startNode" in obj && "endNode" in obj && "properties" in obj) {
+            return obj.type;
+        }
+
+        // If it's a node record (has id field)
+        if ("id" in obj) {
+            return obj.id;
+        }
+
+        throw new Error("id() expects a node or relationship");
+    }
+}
+
+export default Id;

package/src/parsing/functions/last.ts

@@ -0,0 +1,42 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Returns the last element of a list",
+    category: "scalar",
+    parameters: [
+        {
+            name: "list",
+            description: "The list to get the last element from",
+            type: "array",
+        },
+    ],
+    output: {
+        description: "The last element of the list",
+        type: "any",
+        example: "3",
+    },
+    examples: ["RETURN last([1, 2, 3])", "WITH ['a', 'b', 'c'] AS items RETURN last(items)"],
+})
+class Last extends Function {
+    constructor() {
+        super("last");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (val === null || val === undefined) {
+            return null;
+        }
+        if (!Array.isArray(val)) {
+            throw new Error("last() expects a list");
+        }
+        if (val.length === 0) {
+            return null;
+        }
+        return val[val.length - 1];
+    }
+}
+
+export default Last;

package/src/parsing/functions/localdatetime.ts

@@ -0,0 +1,65 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+import { buildDatetimeObject, parseTemporalArg } from "./temporal_utils";
+
+/**
+ * Returns a local datetime value (date + time, no timezone offset).
+ * When called with no arguments, returns the current local datetime.
+ * When called with a string argument, parses it as an ISO 8601 datetime.
+ * When called with a map argument, constructs a datetime from components.
+ *
+ * Equivalent to Neo4j's localdatetime() function.
+ *
+ * @example
+ * ```
+ * RETURN localdatetime() AS now
+ * RETURN localdatetime('2025-06-15T12:30:00') AS dt
+ * ```
+ */
+@FunctionDef({
+    description:
+        "Returns a local datetime value (no timezone). With no arguments returns the current local datetime. " +
+        "Accepts an ISO 8601 string or a map of components.",
+    category: "scalar",
+    parameters: [
+        {
+            name: "input",
+            description: "Optional. An ISO 8601 datetime string or a map of components.",
+            type: "string",
+            required: false,
+        },
+    ],
+    output: {
+        description:
+            "A datetime object with properties: year, month, day, hour, minute, second, millisecond, " +
+            "epochMillis, epochSeconds, dayOfWeek, dayOfYear, quarter, formatted",
+        type: "object",
+    },
+    examples: [
+        "RETURN localdatetime() AS now",
+        "RETURN localdatetime('2025-06-15T12:30:00') AS dt",
+        "WITH localdatetime() AS dt RETURN dt.hour, dt.minute",
+    ],
+})
+class LocalDatetime extends Function {
+    constructor() {
+        super("localdatetime");
+        this._expectedParameterCount = null;
+    }
+
+    public value(): any {
+        const children = this.getChildren();
+        if (children.length > 1) {
+            throw new Error("localdatetime() accepts at most one argument");
+        }
+
+        const d: Date =
+            children.length === 1
+                ? parseTemporalArg(children[0].value(), "localdatetime")
+                : new Date();
+
+        return buildDatetimeObject(d, false);
+    }
+}
+
+export default LocalDatetime;

package/src/parsing/functions/localtime.ts

@@ -0,0 +1,60 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+import { buildTimeObject, parseTemporalArg } from "./temporal_utils";
+
+/**
+ * Returns a local time value (no timezone offset).
+ * When called with no arguments, returns the current local time.
+ * When called with a string argument, parses it.
+ *
+ * Equivalent to Neo4j's localtime() function.
+ *
+ * @example
+ * ```
+ * RETURN localtime() AS now
+ * RETURN localtime('14:30:00') AS t
+ * ```
+ */
+@FunctionDef({
+    description:
+        "Returns a local time value (no timezone). With no arguments returns the current local time. " +
+        "Accepts an ISO 8601 time string or a map of components.",
+    category: "scalar",
+    parameters: [
+        {
+            name: "input",
+            description: "Optional. An ISO 8601 time string (HH:MM:SS) or a map of components.",
+            type: "string",
+            required: false,
+        },
+    ],
+    output: {
+        description: "A time object with properties: hour, minute, second, millisecond, formatted",
+        type: "object",
+    },
+    examples: [
+        "RETURN localtime() AS now",
+        "RETURN localtime('14:30:00') AS t",
+        "WITH localtime() AS t RETURN t.hour, t.minute",
+    ],
+})
+class LocalTime extends Function {
+    constructor() {
+        super("localtime");
+        this._expectedParameterCount = null;
+    }
+
+    public value(): any {
+        const children = this.getChildren();
+        if (children.length > 1) {
+            throw new Error("localtime() accepts at most one argument");
+        }
+
+        const d: Date =
+            children.length === 1 ? parseTemporalArg(children[0].value(), "localtime") : new Date();
+
+        return buildTimeObject(d, false);
+    }
+}
+
+export default LocalTime;

package/src/parsing/functions/max.ts

@@ -0,0 +1,37 @@
+import AggregateFunction from "./aggregate_function";
+import { FunctionDef } from "./function_metadata";
+import ReducerElement from "./reducer_element";
+
+class MaxReducerElement extends ReducerElement {
+    private _value: any = null;
+    public get value(): any {
+        return this._value;
+    }
+    public set value(value: any) {
+        if (this._value === null || value > this._value) {
+            this._value = value;
+        }
+    }
+}
+
+@FunctionDef({
+    description: "Returns the maximum value across grouped rows",
+    category: "aggregate",
+    parameters: [{ name: "value", description: "Value to compare", type: "number" }],
+    output: { description: "Maximum value", type: "number", example: 10 },
+    examples: ["WITH [3, 1, 2] AS nums UNWIND nums AS n RETURN max(n)"],
+})
+class Max extends AggregateFunction {
+    constructor() {
+        super("max");
+        this._expectedParameterCount = 1;
+    }
+    public reduce(element: MaxReducerElement): void {
+        element.value = this.firstChild().value();
+    }
+    public element(): MaxReducerElement {
+        return new MaxReducerElement();
+    }
+}
+
+export default Max;

package/src/parsing/functions/min.ts

@@ -0,0 +1,37 @@
+import AggregateFunction from "./aggregate_function";
+import { FunctionDef } from "./function_metadata";
+import ReducerElement from "./reducer_element";
+
+class MinReducerElement extends ReducerElement {
+    private _value: any = null;
+    public get value(): any {
+        return this._value;
+    }
+    public set value(value: any) {
+        if (this._value === null || value < this._value) {
+            this._value = value;
+        }
+    }
+}
+
+@FunctionDef({
+    description: "Returns the minimum value across grouped rows",
+    category: "aggregate",
+    parameters: [{ name: "value", description: "Value to compare", type: "number" }],
+    output: { description: "Minimum value", type: "number", example: 1 },
+    examples: ["WITH [3, 1, 2] AS nums UNWIND nums AS n RETURN min(n)"],
+})
+class Min extends AggregateFunction {
+    constructor() {
+        super("min");
+        this._expectedParameterCount = 1;
+    }
+    public reduce(element: MinReducerElement): void {
+        element.value = this.firstChild().value();
+    }
+    public element(): MinReducerElement {
+        return new MinReducerElement();
+    }
+}
+
+export default Min;

package/src/parsing/functions/nodes.ts

@@ -0,0 +1,54 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Returns all nodes in a path as an array",
+    category: "scalar",
+    parameters: [
+        {
+            name: "path",
+            description: "A path value returned from a graph pattern match",
+            type: "array",
+        },
+    ],
+    output: {
+        description: "Array of node records",
+        type: "array",
+        example: "[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]",
+    },
+    examples: ["MATCH p=(:Person)-[:KNOWS]-(:Person) RETURN nodes(p)"],
+})
+class Nodes extends Function {
+    constructor() {
+        super("nodes");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const path = this.getChildren()[0].value();
+        if (path === null || path === undefined) {
+            return [];
+        }
+        if (!Array.isArray(path)) {
+            throw new Error("nodes() expects a path (array)");
+        }
+        // A path is an array of alternating node and relationship objects:
+        // [node, rel, node, rel, node, ...]
+        // Nodes are plain NodeRecords (have 'id' but not 'type'/'startNode'/'endNode')
+        // Relationships are RelationshipMatchRecords (have 'type', 'startNode', 'endNode', 'properties')
+        return path.filter((element: any) => {
+            if (element === null || element === undefined || typeof element !== "object") {
+                return false;
+            }
+            // A RelationshipMatchRecord has type, startNode, endNode, properties
+            return !(
+                "type" in element &&
+                "startNode" in element &&
+                "endNode" in element &&
+                "properties" in element
+            );
+        });
+    }
+}
+
+export default Nodes;

package/src/parsing/functions/predicate_sum.ts

@@ -1,17 +1,26 @@
-import PredicateFunction from "./predicate_function";
 import { FunctionDef } from "./function_metadata";
+import PredicateFunction from "./predicate_function";
 
 @FunctionDef({
-    description: "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
+    description:
+        "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
     category: "predicate",
     parameters: [
         { name: "variable", description: "Variable name to bind each element", type: "string" },
         { name: "array", description: "Array to iterate over", type: "array" },
         { name: "expression", description: "Expression to sum for each element", type: "any" },
-        { name: "where", description: "Optional filter condition", type: "boolean", required: false }
+        {
+            name: "where",
+            description: "Optional filter condition",
+            type: "boolean",
+            required: false,
+        },
     ],
     output: { description: "Sum of the evaluated expressions", type: "number", example: 6 },
-    examples: ["WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)", "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)"]
+    examples: [
+        "WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)",
+        "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)",
+    ],
 })
 class PredicateSum extends PredicateFunction {
     constructor() {
@@ -24,19 +33,15 @@ class PredicateSum extends PredicateFunction {
         if (array === null || !Array.isArray(array)) {
             throw new Error("Invalid array for sum function");
         }
-        let _sum: any | null = null;
-        for(let i = 0; i < array.length; i++) {
+        let _sum: number = 0;
+        for (let i = 0; i < array.length; i++) {
             this._valueHolder.holder = array[i];
             if (this.where === null || this.where.value()) {
-                if (_sum === null) {
-                    _sum = this._return.value();
-                } else {
-                    _sum += this._return.value();
-                }
+                _sum += this._return.value();
             }
         }
         return _sum;
     }
 }
 
-export default PredicateSum;
+export default PredicateSum;

package/src/parsing/functions/properties.ts

@@ -0,0 +1,56 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description:
+        "Returns a map containing all the properties of a node, relationship, or map. For nodes and relationships, internal identifiers are excluded.",
+    category: "scalar",
+    parameters: [
+        {
+            name: "entity",
+            description: "A node, relationship, or map to extract properties from",
+            type: "object",
+        },
+    ],
+    output: {
+        description: "Map of properties",
+        type: "object",
+        example: "{ name: 'Alice', age: 30 }",
+    },
+    examples: [
+        "MATCH (n:Person) RETURN properties(n)",
+        "WITH { name: 'Alice', age: 30 } AS obj RETURN properties(obj)",
+    ],
+})
+class Properties extends Function {
+    constructor() {
+        super("properties");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const obj = this.getChildren()[0].value();
+        if (obj === null || obj === undefined) {
+            return null;
+        }
+        if (typeof obj !== "object" || Array.isArray(obj)) {
+            throw new Error("properties() expects a node, relationship, or map");
+        }
+
+        // If it's a RelationshipMatchRecord (has type, startNode, endNode, properties)
+        if ("type" in obj && "startNode" in obj && "endNode" in obj && "properties" in obj) {
+            return obj.properties;
+        }
+
+        // If it's a node record (has id field), exclude id
+        if ("id" in obj) {
+            const { id, ...props } = obj;
+            return props;
+        }
+
+        // Otherwise, treat as a plain map and return a copy
+        return { ...obj };
+    }
+}
+
+export default Properties;

package/src/parsing/functions/relationships.ts

@@ -0,0 +1,52 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Returns all relationships in a path as an array",
+    category: "scalar",
+    parameters: [
+        {
+            name: "path",
+            description: "A path value returned from a graph pattern match",
+            type: "array",
+        },
+    ],
+    output: {
+        description: "Array of relationship records",
+        type: "array",
+        example: "[{ type: 'KNOWS', properties: { since: '2020' } }]",
+    },
+    examples: ["MATCH p=(:Person)-[:KNOWS]-(:Person) RETURN relationships(p)"],
+})
+class Relationships extends Function {
+    constructor() {
+        super("relationships");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const path = this.getChildren()[0].value();
+        if (path === null || path === undefined) {
+            return [];
+        }
+        if (!Array.isArray(path)) {
+            throw new Error("relationships() expects a path (array)");
+        }
+        // A path is an array of alternating node and relationship objects:
+        // [node, rel, node, rel, node, ...]
+        // Relationships are RelationshipMatchRecords (have 'type', 'startNode', 'endNode', 'properties')
+        return path.filter((element: any) => {
+            if (element === null || element === undefined || typeof element !== "object") {
+                return false;
+            }
+            return (
+                "type" in element &&
+                "startNode" in element &&
+                "endNode" in element &&
+                "properties" in element
+            );
+        });
+    }
+}
+
+export default Relationships;

package/src/parsing/functions/schema.ts

@@ -5,8 +5,11 @@ import { FunctionDef } from "./function_metadata";
 /**
  * Built-in function that returns the graph schema of the database.
  *
- * Lists all nodes and relationships with their labels/types and a sample
- * of their data (excluding id from nodes, left_id and right_id from relationships).
+ * Lists all nodes and relationships with their labels/types, properties,
+ * and a sample of their data (excluding id from nodes, left_id and right_id from relationships).
+ *
+ * Nodes: {label, properties, sample}
+ * Relationships: {type, from_label, to_label, properties, sample}
  *
  * @example
  * ```
@@ -15,11 +18,11 @@ import { FunctionDef } from "./function_metadata";
  */
 @FunctionDef({
     description:
-        "Returns the graph schema listing all nodes and relationships with a sample of their data.",
+        "Returns the graph schema listing all nodes and relationships with their properties and a sample of their data.",
     category: "async",
     parameters: [],
     output: {
-        description: "Schema entry with kind, label/type, and optional sample data",
+        description: "Schema entry with label/type, properties, and optional sample data",
         type: "object",
     },
     examples: ["LOAD FROM schema() AS s RETURN s"],

package/src/parsing/functions/tail.ts

@@ -0,0 +1,39 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Returns all elements of a list except the first",
+    category: "scalar",
+    parameters: [
+        {
+            name: "list",
+            description: "The list to get all but the first element from",
+            type: "array",
+        },
+    ],
+    output: {
+        description: "All elements except the first",
+        type: "array",
+        example: "[2, 3]",
+    },
+    examples: ["RETURN tail([1, 2, 3])", "WITH ['a', 'b', 'c'] AS items RETURN tail(items)"],
+})
+class Tail extends Function {
+    constructor() {
+        super("tail");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (val === null || val === undefined) {
+            return null;
+        }
+        if (!Array.isArray(val)) {
+            throw new Error("tail() expects a list");
+        }
+        return val.slice(1);
+    }
+}
+
+export default Tail;