flowquery 1.0.46 → 1.0.48

package/src/parsing/functions/min.ts

@@ -1,37 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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_function.ts

@@ -1,48 +0,0 @@
-import ASTNode from "../ast_node";
-import Expression from "../expressions/expression";
-import Reference from "../expressions/reference";
-import Where from "../operations/where";
-import ValueHolder from "./value_holder";
-
-class PredicateFunction extends ASTNode {
-    private _name: string;
-    protected _valueHolder: ValueHolder = new ValueHolder();
-
-    constructor(name?: string) {
-        super();
-        this._name = name || this.constructor.name;
-    }
-
-    public get name(): string {
-        return this._name;
-    }
-
-    protected get reference(): Reference {
-        return this.firstChild() as Reference;
-    }
-
-    protected get array(): ASTNode {
-        return this.getChildren()[1].firstChild();
-    }
-
-    protected get _return(): Expression {
-        return this.getChildren()[2] as Expression;
-    }
-
-    protected get where(): Where | null {
-        if (this.getChildren().length === 4) {
-            return this.getChildren()[3] as Where;
-        }
-        return null;
-    }
-
-    public value(): any {
-        throw new Error("Method not implemented.");
-    }
-
-    public toString(): string {
-        return `PredicateFunction (${this._name})`;
-    }
-}
-
-export default PredicateFunction;

package/src/parsing/functions/predicate_sum.ts

@@ -1,47 +0,0 @@
-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)",
-    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,
-        },
-    ],
-    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)",
-    ],
-})
-class PredicateSum extends PredicateFunction {
-    constructor() {
-        super("sum");
-    }
-
-    public value(): any {
-        this.reference.referred = this._valueHolder;
-        const array = this.array.value();
-        if (array === null || !Array.isArray(array)) {
-            throw new Error("Invalid array for sum function");
-        }
-        let _sum: number = 0;
-        for (let i = 0; i < array.length; i++) {
-            this._valueHolder.holder = array[i];
-            if (this.where === null || this.where.value()) {
-                _sum += this._return.value();
-            }
-        }
-        return _sum;
-    }
-}
-
-export default PredicateSum;

package/src/parsing/functions/properties.ts

@@ -1,56 +0,0 @@
-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/rand.ts

@@ -1,21 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Generates a random number between 0 and 1",
-    category: "scalar",
-    parameters: [],
-    output: { description: "Random number between 0 and 1", type: "number", example: 0.7234 },
-    examples: ["WITH rand() AS r RETURN r"]
-})
-class Rand extends Function {
-    constructor() {
-        super("rand");
-        this._expectedParameterCount = 0;
-    }
-    public value(): any {
-        return Math.random();
-    }
-}
-
-export default Rand;

package/src/parsing/functions/range.ts

@@ -1,37 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Generates an array of sequential integers",
-    category: "scalar",
-    parameters: [
-        { name: "start", description: "Starting number (inclusive)", type: "number" },
-        { name: "end", description: "Ending number (inclusive)", type: "number" },
-    ],
-    output: {
-        description: "Array of integers from start to end",
-        type: "array",
-        items: { type: "number" },
-        example: [1, 2, 3, 4, 5],
-    },
-    examples: ["WITH range(1, 5) AS nums RETURN nums"],
-})
-class Range extends Function {
-    constructor() {
-        super("range");
-        this._expectedParameterCount = 2;
-    }
-    public value(): any {
-        const start = this.getChildren()[0].value();
-        const end = this.getChildren()[1].value();
-        if (start === null || start === undefined || end === null || end === undefined) {
-            return null;
-        }
-        if (typeof start !== "number" || typeof end !== "number") {
-            throw new Error("Invalid arguments for range function");
-        }
-        return Array.from({ length: end - start + 1 }, (_, i) => start + i);
-    }
-}
-
-export default Range;

package/src/parsing/functions/reducer_element.ts

@@ -1,10 +0,0 @@
-class ReducerElement {
-    public get value(): any {
-        throw new Error("Method not implemented.");
-    }
-    public set value(value: any) {
-        throw new Error("Method not implemented.");
-    }
-}
-
-export default ReducerElement;

package/src/parsing/functions/relationships.ts

@@ -1,52 +0,0 @@
-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/replace.ts

@@ -1,38 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Replaces occurrences of a pattern in a string",
-    category: "scalar",
-    parameters: [
-        { name: "text", description: "Source string", type: "string" },
-        { name: "pattern", description: "Pattern to find", type: "string" },
-        { name: "replacement", description: "Replacement string", type: "string" },
-    ],
-    output: { description: "String with replacements", type: "string", example: "hello world" },
-    examples: ["WITH 'hello there' AS s RETURN replace(s, 'there', 'world')"],
-})
-class Replace extends Function {
-    constructor() {
-        super("replace");
-        this._expectedParameterCount = 3;
-    }
-    public value(): any {
-        const str = this.getChildren()[0].value();
-        const search = this.getChildren()[1].value();
-        const replacement = this.getChildren()[2].value();
-        if (str === null || str === undefined) {
-            return null;
-        }
-        if (
-            typeof str !== "string" ||
-            typeof search !== "string" ||
-            typeof replacement !== "string"
-        ) {
-            throw new Error("Invalid arguments for replace function");
-        }
-        return str.replace(new RegExp(search, "g"), replacement);
-    }
-}
-
-export default Replace;

package/src/parsing/functions/round.ts

@@ -1,28 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Rounds a number to the nearest integer",
-    category: "scalar",
-    parameters: [{ name: "value", description: "Number to round", type: "number" }],
-    output: { description: "Rounded integer", type: "number", example: 4 },
-    examples: ["WITH 3.7 AS n RETURN round(n)"],
-})
-class Round extends Function {
-    constructor() {
-        super("round");
-        this._expectedParameterCount = 1;
-    }
-    public value(): any {
-        const value = this.getChildren()[0].value();
-        if (value === null || value === undefined) {
-            return null;
-        }
-        if (typeof value !== "number") {
-            throw new Error("Invalid argument for round function");
-        }
-        return Math.round(value);
-    }
-}
-
-export default Round;

package/src/parsing/functions/schema.ts

@@ -1,39 +0,0 @@
-import Database from "../../graph/database";
-import AsyncFunction from "./async_function";
-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, 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
- * ```
- * LOAD FROM schema() AS s RETURN s
- * ```
- */
-@FunctionDef({
-    description:
-        "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 label/type, properties, and optional sample data",
-        type: "object",
-    },
-    examples: ["LOAD FROM schema() AS s RETURN s"],
-})
-class Schema extends AsyncFunction {
-    public async *generate(): AsyncGenerator<any> {
-        const entries = await Database.getInstance().schema();
-        for (const entry of entries) {
-            yield entry;
-        }
-    }
-}
-
-export default Schema;

package/src/parsing/functions/size.ts

@@ -1,28 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Returns the length of an array or string",
-    category: "scalar",
-    parameters: [{ name: "value", description: "Array or string to measure", type: "array" }],
-    output: { description: "Length of the input", type: "number", example: 3 },
-    examples: ["WITH [1, 2, 3] AS arr RETURN size(arr)"],
-})
-class Size extends Function {
-    constructor() {
-        super("size");
-        this._expectedParameterCount = 1;
-    }
-    public value(): any {
-        const arr = this.getChildren()[0].value();
-        if (arr === null || arr === undefined) {
-            return null;
-        }
-        if (!Array.isArray(arr)) {
-            throw new Error("Invalid argument for size function");
-        }
-        return arr.length;
-    }
-}
-
-export default Size;

package/src/parsing/functions/split.ts

@@ -1,45 +0,0 @@
-import ASTNode from "../ast_node";
-import String from "../expressions/string";
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Splits a string into an array by a delimiter",
-    category: "scalar",
-    parameters: [
-        { name: "text", description: "String to split", type: "string" },
-        { name: "delimiter", description: "Delimiter to split by", type: "string" },
-    ],
-    output: {
-        description: "Array of string parts",
-        type: "array",
-        items: { type: "string" },
-        example: ["a", "b", "c"],
-    },
-    examples: ["WITH 'a,b,c' AS s RETURN split(s, ',')"],
-})
-class Split extends Function {
-    constructor() {
-        super("split");
-        this._expectedParameterCount = 2;
-    }
-    public set parameters(nodes: ASTNode[]) {
-        if (nodes.length === 1) {
-            nodes.push(new String(""));
-        }
-        super.parameters = nodes;
-    }
-    public value(): any {
-        const str = this.getChildren()[0].value();
-        const delimiter = this.getChildren()[1].value();
-        if (str === null || str === undefined) {
-            return null;
-        }
-        if (typeof str !== "string" || typeof delimiter !== "string") {
-            throw new Error("Invalid arguments for split function");
-        }
-        return str.split(delimiter);
-    }
-}
-
-export default Split;

package/src/parsing/functions/string_distance.ts

@@ -1,83 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-/**
- * Computes the normalized Levenshtein distance between two strings.
- * The Levenshtein distance is the minimum number of single-character edits
- * (insertions, deletions, or substitutions) required to change one string into the other.
- * The result is normalized to [0, 1] by dividing by the length of the longer string.
- *
- * @param a - First string
- * @param b - Second string
- * @returns The normalized Levenshtein distance (0 = identical, 1 = completely different)
- */
-function levenshteinDistance(a: string, b: string): number {
-    const m = a.length;
-    const n = b.length;
-
-    // Both empty strings are identical
-    if (m === 0 && n === 0) return 0;
-
-    // Create a matrix of size (m+1) x (n+1)
-    const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-
-    // Base cases: transforming empty string to/from a prefix
-    for (let i = 0; i <= m; i++) dp[i][0] = i;
-    for (let j = 0; j <= n; j++) dp[0][j] = j;
-
-    // Fill in the rest of the matrix
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            dp[i][j] = Math.min(
-                dp[i - 1][j] + 1, // deletion
-                dp[i][j - 1] + 1, // insertion
-                dp[i - 1][j - 1] + cost // substitution
-            );
-        }
-    }
-
-    // Normalize by the length of the longer string
-    return dp[m][n] / Math.max(m, n);
-}
-
-@FunctionDef({
-    description:
-        "Computes the normalized Levenshtein distance between two strings. Returns a value in [0, 1] where 0 means identical and 1 means completely different.",
-    category: "scalar",
-    parameters: [
-        { name: "string1", description: "First string", type: "string" },
-        { name: "string2", description: "Second string", type: "string" },
-    ],
-    output: {
-        description: "Normalized Levenshtein distance (0 = identical, 1 = completely different)",
-        type: "number",
-        example: 0.43,
-    },
-    examples: [
-        "RETURN string_distance('kitten', 'sitting')",
-        "WITH 'hello' AS a, 'hallo' AS b RETURN string_distance(a, b)",
-    ],
-})
-class StringDistance extends Function {
-    constructor() {
-        super("string_distance");
-        this._expectedParameterCount = 2;
-    }
-
-    public value(): any {
-        const str1 = this.getChildren()[0].value();
-        const str2 = this.getChildren()[1].value();
-        if (str1 === null || str1 === undefined || str2 === null || str2 === undefined) {
-            return null;
-        }
-        if (typeof str1 !== "string" || typeof str2 !== "string") {
-            throw new Error(
-                "Invalid arguments for string_distance function: both arguments must be strings"
-            );
-        }
-        return levenshteinDistance(str1, str2);
-    }
-}
-
-export default StringDistance;

package/src/parsing/functions/stringify.ts

@@ -1,37 +0,0 @@
-import ASTNode from "../ast_node";
-import Number from "../expressions/number";
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-@FunctionDef({
-    description: "Converts a value to its JSON string representation",
-    category: "scalar",
-    parameters: [{ name: "value", description: "Value to stringify", type: "any" }],
-    output: { description: "JSON string", type: "string", example: '{"a":1}' },
-    examples: ["WITH {a: 1} AS obj RETURN stringify(obj)"],
-})
-class Stringify extends Function {
-    constructor() {
-        super("stringify");
-        this._expectedParameterCount = 2;
-    }
-    public set parameters(nodes: ASTNode[]) {
-        if (nodes.length === 1) {
-            nodes.push(new Number("3")); // Default to 3 if only one parameter is provided
-        }
-        super.parameters = nodes;
-    }
-    public value(): any {
-        const value = this.getChildren()[0].value();
-        const indent = parseInt(this.getChildren()[1].value());
-        if (value === null || value === undefined) {
-            return null;
-        }
-        if (typeof value !== "object") {
-            throw new Error("Invalid argument for stringify function");
-        }
-        return JSON.stringify(value, null, indent);
-    }
-}
-
-export default Stringify;