flowquery 1.0.27 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "description": "A declarative query language for data processing pipelines.",
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",

package/src/graph/relationship.ts

@@ -133,7 +133,7 @@ class Relationship extends ASTNode {
         const followId = isLeft ? "left_id" : "right_id";
         while (findMatch(left_id, hop)) {
             const data: RelationshipRecord = this._data?.current(hop) as RelationshipRecord;
-            if (hop >= this.hops!.min) {
+            if (hop + 1 >= this.hops!.min) {
                 this.setValue(this);
                 if (!this._matchesProperties(hop)) {
                     continue;
@@ -146,6 +146,9 @@ class Relationship extends ASTNode {
                     await this.find(data[followId], hop + 1);
                 }
                 this._matches.pop();
+            } else {
+                // Below minimum hops: traverse the edge without yielding a match
+                await this.find(data[followId], hop + 1);
             }
         }
         // Restore original source node

package/src/parsing/base_parser.ts

@@ -9,7 +9,7 @@ import Tokenizer from "../tokenization/tokenizer";
  */
 class BaseParser {
     private tokens: Token[] = <Token[]>[];
-    private tokenIndex: number = 0;
+    protected tokenIndex: number = 0;
 
     constructor(tokens: Token[] | null = null) {
         if (tokens !== null) {

package/src/parsing/expressions/operator.ts

@@ -172,7 +172,126 @@ class Is extends Operator {
         super(-1, true);
     }
     public value(): number {
-        return this.lhs.value() === this.rhs.value() ? 1 : 0;
+        return this.lhs.value() == this.rhs.value() ? 1 : 0;
+    }
+}
+
+class IsNot extends Operator {
+    constructor() {
+        super(-1, true);
+    }
+    public value(): number {
+        return this.lhs.value() != this.rhs.value() ? 1 : 0;
+    }
+}
+
+class In extends Operator {
+    constructor() {
+        super(-1, true);
+    }
+    public value(): number {
+        const list = this.rhs.value();
+        if (!Array.isArray(list)) {
+            throw new Error("Right operand of IN must be a list");
+        }
+        return list.includes(this.lhs.value()) ? 1 : 0;
+    }
+}
+
+class NotIn extends Operator {
+    constructor() {
+        super(-1, true);
+    }
+    public value(): number {
+        const list = this.rhs.value();
+        if (!Array.isArray(list)) {
+            throw new Error("Right operand of NOT IN must be a list");
+        }
+        return list.includes(this.lhs.value()) ? 0 : 1;
+    }
+}
+
+class Contains extends Operator {
+    constructor() {
+        super(0, true);
+    }
+    public value(): number {
+        const str = this.lhs.value();
+        const search = this.rhs.value();
+        if (typeof str !== "string" || typeof search !== "string") {
+            throw new Error("CONTAINS requires string operands");
+        }
+        return str.includes(search) ? 1 : 0;
+    }
+}
+
+class NotContains extends Operator {
+    constructor() {
+        super(0, true);
+    }
+    public value(): number {
+        const str = this.lhs.value();
+        const search = this.rhs.value();
+        if (typeof str !== "string" || typeof search !== "string") {
+            throw new Error("NOT CONTAINS requires string operands");
+        }
+        return str.includes(search) ? 0 : 1;
+    }
+}
+
+class StartsWith extends Operator {
+    constructor() {
+        super(0, true);
+    }
+    public value(): number {
+        const str = this.lhs.value();
+        const search = this.rhs.value();
+        if (typeof str !== "string" || typeof search !== "string") {
+            throw new Error("STARTS WITH requires string operands");
+        }
+        return str.startsWith(search) ? 1 : 0;
+    }
+}
+
+class NotStartsWith extends Operator {
+    constructor() {
+        super(0, true);
+    }
+    public value(): number {
+        const str = this.lhs.value();
+        const search = this.rhs.value();
+        if (typeof str !== "string" || typeof search !== "string") {
+            throw new Error("NOT STARTS WITH requires string operands");
+        }
+        return str.startsWith(search) ? 0 : 1;
+    }
+}
+
+class EndsWith extends Operator {
+    constructor() {
+        super(0, true);
+    }
+    public value(): number {
+        const str = this.lhs.value();
+        const search = this.rhs.value();
+        if (typeof str !== "string" || typeof search !== "string") {
+            throw new Error("ENDS WITH requires string operands");
+        }
+        return str.endsWith(search) ? 1 : 0;
+    }
+}
+
+class NotEndsWith extends Operator {
+    constructor() {
+        super(0, true);
+    }
+    public value(): number {
+        const str = this.lhs.value();
+        const search = this.rhs.value();
+        if (typeof str !== "string" || typeof search !== "string") {
+            throw new Error("NOT ENDS WITH requires string operands");
+        }
+        return str.endsWith(search) ? 0 : 1;
     }
 }
 
@@ -194,4 +313,13 @@ export {
     Or,
     Not,
     Is,
+    IsNot,
+    In,
+    NotIn,
+    Contains,
+    NotContains,
+    StartsWith,
+    NotStartsWith,
+    EndsWith,
+    NotEndsWith,
 };

package/src/parsing/functions/function_factory.ts

@@ -21,6 +21,7 @@ import "./round";
 import "./schema";
 import "./size";
 import "./split";
+import "./string_distance";
 import "./stringify";
 // Import built-in functions to ensure their @FunctionDef decorators run
 import "./sum";

package/src/parsing/functions/string_distance.ts

@@ -0,0 +1,80 @@
+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 (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/parser.ts

@@ -24,7 +24,19 @@ import RangeLookup from "./data_structures/range_lookup";
 import Expression from "./expressions/expression";
 import FString from "./expressions/f_string";
 import Identifier from "./expressions/identifier";
-import { Not } from "./expressions/operator";
+import {
+    Contains,
+    EndsWith,
+    In,
+    Is,
+    IsNot,
+    Not,
+    NotContains,
+    NotEndsWith,
+    NotIn,
+    NotStartsWith,
+    StartsWith,
+} from "./expressions/operator";
 import Reference from "./expressions/reference";
 import String from "./expressions/string";
 import AggregateFunction from "./functions/aggregate_function";
@@ -434,10 +446,7 @@ class Parser extends BaseParser {
         let node = new Node();
         node.properties = new Map(this.parseProperties());
         node.label = label!;
-        if (label !== null && identifier !== null) {
-            node.identifier = identifier;
-            this.variables.set(identifier, node);
-        } else if (identifier !== null) {
+        if (identifier !== null && this.variables.has(identifier)) {
             let reference = this.variables.get(identifier);
             // Resolve through Expression -> Reference -> Node (e.g., after WITH)
             if (reference instanceof Expression && reference.firstChild() instanceof Reference) {
@@ -450,6 +459,9 @@ class Parser extends BaseParser {
                 throw new Error(`Undefined node reference: ${identifier}`);
             }
             node = new NodeReference(node, reference);
+        } else if (identifier !== null) {
+            node.identifier = identifier;
+            this.variables.set(identifier, node);
         }
         if (!this.token.isRightParenthesis()) {
             throw new Error("Expected closing parenthesis for node definition");
@@ -632,10 +644,7 @@ class Parser extends BaseParser {
         let relationship = new Relationship();
         relationship.direction = direction;
         relationship.properties = properties;
-        if (type !== null && variable !== null) {
-            relationship.identifier = variable;
-            this.variables.set(variable, relationship);
-        } else if (variable !== null) {
+        if (variable !== null && this.variables.has(variable)) {
             let reference = this.variables.get(variable);
             // Resolve through Expression -> Reference -> Relationship (e.g., after WITH)
             if (reference instanceof Expression && reference.firstChild() instanceof Reference) {
@@ -648,6 +657,9 @@ class Parser extends BaseParser {
                 throw new Error(`Undefined relationship reference: ${variable}`);
             }
             relationship = new RelationshipReference(relationship, reference);
+        } else if (variable !== null) {
+            relationship.identifier = variable;
+            this.variables.set(variable, relationship);
         }
         if (hops !== null) {
             relationship.hops = hops;
@@ -853,7 +865,25 @@ class Parser extends BaseParser {
             }
             this.skipWhitespaceAndComments();
             if (this.token.isOperator()) {
-                expression.addNode(this.token.node);
+                if (this.token.isIs()) {
+                    expression.addNode(this.parseIsOperator());
+                } else {
+                    expression.addNode(this.token.node);
+                }
+            } else if (this.token.isIn()) {
+                expression.addNode(this.parseInOperator());
+            } else if (this.token.isContains()) {
+                expression.addNode(this.parseContainsOperator());
+            } else if (this.token.isStarts()) {
+                expression.addNode(this.parseStartsWithOperator());
+            } else if (this.token.isEnds()) {
+                expression.addNode(this.parseEndsWithOperator());
+            } else if (this.token.isNot()) {
+                const notOp = this.parseNotOperator();
+                if (notOp === null) {
+                    break;
+                }
+                expression.addNode(notOp);
             } else {
                 break;
             }
@@ -866,6 +896,86 @@ class Parser extends BaseParser {
         return null;
     }
 
+    private parseIsOperator(): Is | IsNot {
+        // Current token is IS. Look ahead for NOT to produce IS NOT.
+        const savedIndex = this.tokenIndex;
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        if (this.token.isNot()) {
+            return new IsNot();
+        }
+        // Not IS NOT — restore position to IS so the outer loop's setNextToken advances past it.
+        this.tokenIndex = savedIndex;
+        return new Is();
+    }
+
+    private parseInOperator(): In | NotIn {
+        // Current token is IN. Advance past it so the outer loop's setNextToken moves correctly.
+        return new In();
+    }
+
+    private parseContainsOperator(): Contains {
+        return new Contains();
+    }
+
+    private parseStartsWithOperator(): StartsWith {
+        // Current token is STARTS. Look ahead for WITH.
+        const savedIndex = this.tokenIndex;
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        if (this.token.isWith()) {
+            return new StartsWith();
+        }
+        this.tokenIndex = savedIndex;
+        throw new Error("Expected WITH after STARTS");
+    }
+
+    private parseEndsWithOperator(): EndsWith {
+        // Current token is ENDS. Look ahead for WITH.
+        const savedIndex = this.tokenIndex;
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        if (this.token.isWith()) {
+            return new EndsWith();
+        }
+        this.tokenIndex = savedIndex;
+        throw new Error("Expected WITH after ENDS");
+    }
+
+    private parseNotOperator(): NotIn | NotContains | NotStartsWith | NotEndsWith | null {
+        // Current token is NOT. Look ahead for IN, CONTAINS, STARTS WITH, or ENDS WITH.
+        const savedIndex = this.tokenIndex;
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        if (this.token.isIn()) {
+            return new NotIn();
+        }
+        if (this.token.isContains()) {
+            return new NotContains();
+        }
+        if (this.token.isStarts()) {
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (this.token.isWith()) {
+                return new NotStartsWith();
+            }
+            this.tokenIndex = savedIndex;
+            return null;
+        }
+        if (this.token.isEnds()) {
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (this.token.isWith()) {
+                return new NotEndsWith();
+            }
+            this.tokenIndex = savedIndex;
+            return null;
+        }
+        // Not a recognized NOT operator — restore position and let the outer loop break.
+        this.tokenIndex = savedIndex;
+        return null;
+    }
+
     private parseLookup(node: ASTNode): ASTNode {
         let variable: ASTNode = node;
         let lookup: Lookup | RangeLookup | null = null;

package/src/tokenization/keyword.ts

@@ -39,6 +39,9 @@ enum Keyword {
     END = "END",
     NULL = "NULL",
     IN = "IN",
+    CONTAINS = "CONTAINS",
+    STARTS = "STARTS",
+    ENDS = "ENDS",
 }
 
 export default Keyword;

package/src/tokenization/token.ts

@@ -627,6 +627,30 @@ class Token {
         return this._type === TokenType.KEYWORD && this._value === Keyword.IN;
     }
 
+    public static get CONTAINS(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.CONTAINS);
+    }
+
+    public isContains(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.CONTAINS;
+    }
+
+    public static get STARTS(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.STARTS);
+    }
+
+    public isStarts(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.STARTS;
+    }
+
+    public static get ENDS(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.ENDS);
+    }
+
+    public isEnds(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.ENDS;
+    }
+
     public static get PIPE(): Token {
         return new Token(TokenType.KEYWORD, Operator.PIPE);
     }