@surrealdb/lezer 1.0.3 → 1.0.4

package/test/statements/use.txt

@@ -0,0 +1,39 @@
+# Use namespace short
+
+USE NS test
+
+==>
+
+SurrealQL(UseStatement(Keyword,Keyword,Ident))
+
+# Use namespace long
+
+USE NAMESPACE test
+
+==>
+
+SurrealQL(UseStatement(Keyword,Keyword,Ident))
+
+# Use database short
+
+USE DB test
+
+==>
+
+SurrealQL(UseStatement(Keyword,Keyword,Ident))
+
+# Use database long
+
+USE DATABASE test
+
+==>
+
+SurrealQL(UseStatement(Keyword,Keyword,Ident))
+
+# Use namespace and database
+
+USE NS test DB test
+
+==>
+
+SurrealQL(UseStatement(Keyword,Keyword,Ident,Keyword,Ident))

package/test/test-surrealql.js

@@ -4,21 +4,93 @@ import { fileTests } from "@lezer/generator/dist/test";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
-let caseDir = path.dirname(fileURLToPath(import.meta.url));
 
-let filter = process.argv[2];
+const testDir = path.dirname(fileURLToPath(import.meta.url));
+const subdirs = ["statements", "values", "misc"];
 
-for (let file of fs.readdirSync(caseDir)) {
-	if (!/\.txt$/.test(file)) continue;
-	console.log("File " + file + ":");
-	for (let { name, run } of fileTests(fs.readFileSync(path.join(caseDir, file), "utf8"), file)) {
-		if (!filter || name.indexOf(filter) > -1) {
+const args = process.argv.slice(2);
+const llmMode = args.includes("--llm");
+const filter = args.find((a) => a !== "--llm");
+
+const green = (s) => (llmMode ? s : `\x1b[32m${s}\x1b[0m`);
+const red = (s) => (llmMode ? s : `\x1b[31m${s}\x1b[0m`);
+const bold = (s) => (llmMode ? s : `\x1b[1m${s}\x1b[0m`);
+const dim = (s) => (llmMode ? s : `\x1b[2m${s}\x1b[0m`);
+
+let totalPass = 0;
+let totalFail = 0;
+const failures = [];
+
+for (const subdir of subdirs) {
+	const dirPath = path.join(testDir, subdir);
+	if (!fs.existsSync(dirPath)) continue;
+
+	if (!llmMode) console.log(`\n${bold(`=== ${subdir.toUpperCase()} ===`)}`);
+
+	for (const file of fs.readdirSync(dirPath).sort()) {
+		if (!/\.txt$/.test(file)) continue;
+
+		const filePath = path.join(dirPath, file);
+		const label = `${subdir}/${file}`;
+		const tests = fileTests(fs.readFileSync(filePath, "utf8"), file);
+
+		let filePass = 0;
+		let fileFail = 0;
+		const fileFailures = [];
+
+		if (!llmMode) console.log(`\n  ${bold(label)}`);
+
+		for (const { name, run } of tests) {
+			if (filter && name.indexOf(filter) === -1) continue;
 			try {
 				run(parser);
-				console.log(" ✔ " + name);
+				filePass++;
+				totalPass++;
+				if (!llmMode) console.log(`    ${green("✔")} ${name}`);
 			} catch (e) {
-				console.log(" ✘ " + name + "\n   " + String(e.message || e).replace(/\n/g, "\n   "))
+				fileFail++;
+				totalFail++;
+				const msg = String(e.message || e);
+				fileFailures.push({ name, msg });
+				if (!llmMode) {
+					console.log(`    ${red("✘")} ${name}\n      ${red(msg.replace(/\n/g, "\n      "))}`);
+				}
+			}
+		}
+
+		if (llmMode && fileFail > 0) {
+			console.log(`FAIL ${label} (${filePass} passed, ${fileFail} failed)`);
+			for (const f of fileFailures) {
+				console.log(`  FAIL: ${f.name}`);
+				console.log(`    ${f.msg.replace(/\n/g, "\n    ")}`);
 			}
 		}
+
+		if (fileFail > 0) {
+			failures.push({ label, fileFailures });
+		}
+
+		if (!llmMode) {
+			console.log(dim(`    ${filePass + fileFail} tests: ${filePass} passed${fileFail > 0 ? `, ${fileFail} failed` : ""}`));
+		}
 	}
 }
+
+console.log("");
+if (llmMode) {
+	console.log("--- SUMMARY ---");
+	console.log(`Total: ${totalPass + totalFail} | Passed: ${totalPass} | Failed: ${totalFail}`);
+	if (failures.length > 0) {
+		console.log("\nFailed tests:");
+		for (const { label, fileFailures } of failures) {
+			for (const f of fileFailures) {
+				console.log(`  [${label}] ${f.name}`);
+			}
+		}
+	}
+} else {
+	const summary = `${bold("Total")}: ${totalPass + totalFail} | ${green(`Passed: ${totalPass}`)} | ${totalFail > 0 ? red(`Failed: ${totalFail}`) : dim("Failed: 0")}`;
+	console.log(summary);
+}
+
+if (totalFail > 0) process.exit(1);

package/test/values/arrays.txt

@@ -0,0 +1,47 @@
+# Empty array
+
+[]
+
+==>
+
+SurrealQL(Array("[","]"))
+
+# Single element
+
+[1]
+
+==>
+
+SurrealQL(Array("[",Int,"]"))
+
+# Multiple elements
+
+[1, 2, 3]
+
+==>
+
+SurrealQL(Array("[",Int,Int,Int,"]"))
+
+# Trailing comma
+
+[1, 2, 3,]
+
+==>
+
+SurrealQL(Array("[",Int,Int,Int,"]"))
+
+# Nested arrays
+
+[[1, 2], [3, 4]]
+
+==>
+
+SurrealQL(Array("[",Array("[",Int,Int,"]"),Array("[",Int,Int,"]"),"]"))
+
+# Mixed types
+
+[1, "hello", true, null]
+
+==>
+
+SurrealQL(Array("[",Int,String,Bool,None,"]"))

package/test/values/casting.txt

@@ -0,0 +1,95 @@
+# Simple type cast
+
+<string> test
+
+==>
+
+SurrealQL(TypeCast("<",TypeName,">",Ident))
+
+# Union type cast
+
+<string|number> test
+
+==>
+
+SurrealQL(TypeCast("<",UnionType(TypeName,Pipe,TypeName),">",Ident))
+
+# Literal string type cast
+
+<"test"> test
+
+==>
+
+SurrealQL(TypeCast("<",LiteralType(String),">",Ident))
+
+# Literal union type cast
+
+<"test"|number> test
+
+==>
+
+SurrealQL(TypeCast("<",UnionType(LiteralType(String),Pipe,TypeName),">",Ident))
+
+# Literal string union
+
+<"a"|"b"> test
+
+==>
+
+SurrealQL(TypeCast("<",UnionType(LiteralType(String),Pipe,LiteralType(String)),">",Ident))
+
+# Array literal type cast
+
+<["test"]> test
+
+==>
+
+SurrealQL(TypeCast("<",LiteralType(ArrayType("[",LiteralType(String),"]")),">",Ident))
+
+# Array union literal type cast
+
+<["test"|number]> test
+
+==>
+
+SurrealQL(TypeCast("<",LiteralType(ArrayType("[",UnionType(LiteralType(String),Pipe,TypeName),"]")),">",Ident))
+
+# Object type cast
+
+<{ "a": string }> test
+
+==>
+
+SurrealQL(TypeCast("<",LiteralType(ObjectType(BraceOpen,ObjectTypeContent(ObjectTypeProperty(ObjectKey(String),Colon,TypeName)),BraceClose)),">",Ident))
+
+# Object union type cast
+
+<{ "a": "test"|number }> test
+
+==>
+
+SurrealQL(TypeCast("<",LiteralType(ObjectType(BraceOpen,ObjectTypeContent(ObjectTypeProperty(ObjectKey(String),Colon,UnionType(LiteralType(String),Pipe,TypeName))),BraceClose)),">",Ident))
+
+# Complex nested type cast
+
+<{ "a": "test"|[number] }|number> test
+
+==>
+
+SurrealQL(TypeCast("<",UnionType(LiteralType(ObjectType(BraceOpen,ObjectTypeContent(ObjectTypeProperty(ObjectKey(String),Colon,UnionType(LiteralType(String),Pipe,LiteralType(ArrayType("[",TypeName,"]"))))),BraceClose)),Pipe,TypeName),">",Ident))
+
+# Parameterized type cast
+
+<record<hello>> test
+
+==>
+
+SurrealQL(TypeCast("<",ParameterizedType(TypeName,"<",TypeName,">"),">",Ident))
+
+# Complex union object type cast
+
+<{ "a": string } | { "b": [record<hello>] | "test" }> test
+
+==>
+
+SurrealQL(TypeCast("<",UnionType(LiteralType(ObjectType(BraceOpen,ObjectTypeContent(ObjectTypeProperty(ObjectKey(String),Colon,TypeName)),BraceClose)),Pipe,LiteralType(ObjectType(BraceOpen,ObjectTypeContent(ObjectTypeProperty(ObjectKey(String),Colon,UnionType(LiteralType(ArrayType("[",ParameterizedType(TypeName,"<",TypeName,">"),"]")),Pipe,LiteralType(String)))),BraceClose))),">",Ident))

package/test/values/closures.txt

@@ -0,0 +1,39 @@
+# Empty closure
+
+|| { 1 }
+
+==>
+
+SurrealQL(Closure(Pipe,Pipe,Block(BraceOpen,Int,BraceClose)))
+
+# Closure with param
+
+|$a| { $a }
+
+==>
+
+SurrealQL(Closure(Pipe,ParamDefinition(VariableName),Pipe,Block(BraceOpen,VariableName,BraceClose)))
+
+# Closure with typed param
+
+|$a: number| { $a + 1 }
+
+==>
+
+SurrealQL(Closure(Pipe,ParamDefinition(VariableName,Colon,Type(TypeName)),Pipe,Block(BraceOpen,BinaryExpression(VariableName,Operator,Int),BraceClose)))
+
+# Closure with multiple params
+
+|$a, $b| { $a + $b }
+
+==>
+
+SurrealQL(Closure(Pipe,ParamDefinition(VariableName),ParamDefinition(VariableName),Pipe,Block(BraceOpen,BinaryExpression(VariableName,Operator,VariableName),BraceClose)))
+
+# Closure with return type
+
+|$a: number| -> number { $a + 1 }
+
+==>
+
+SurrealQL(Closure(Pipe,ParamDefinition(VariableName,Colon,Type(TypeName)),Pipe,LookupRight,TypeName,Block(BraceOpen,BinaryExpression(VariableName,Operator,Int),BraceClose)))

package/test/values/durations.txt

@@ -0,0 +1,41 @@
+# Single duration parts
+
+1ns;
+1us;
+1ms;
+1s;
+1m;
+1h;
+1d;
+1w;
+1y
+
+==>
+
+SurrealQL(
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart),
+  Duration(DurationPart)
+)
+
+# Multi-part duration
+
+1s 1m 1 h
+
+==>
+
+SurrealQL(Duration(DurationPart,DurationPart,DurationPart))
+
+# Complex duration
+
+1d2h30m
+
+==>
+
+SurrealQL(Duration(DurationPart,DurationPart,DurationPart))

package/test/values/format-strings.txt

@@ -0,0 +1,39 @@
+# Basic format string
+
+$"hello {name}"
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,Ident,BraceClose)))
+
+# Format string with expression
+
+$"result is {1 + 2 + 3}"
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,BinaryExpression(BinaryExpression(Int,Operator,Int),Operator,Int),BraceClose)))
+
+# Escaped quote in format string
+
+$"some \" quote {1 + 2 + 3} and \{ some } brackets"
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,BinaryExpression(BinaryExpression(Int,Operator,Int),Operator,Int),BraceClose)))
+
+# Nested format strings
+
+$'nested {$"string {22}"}'
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,FormatString(Interpolation(BraceOpen,Int,BraceClose)),BraceClose)))
+
+# Single quoted format string
+
+$'hello {name}'
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,Ident,BraceClose)))

package/test/values/geometries.txt

@@ -0,0 +1,23 @@
+# Point with decimals
+
+(10dec, 20dec)
+
+==>
+
+SurrealQL(Point(Decimal,Decimal))
+
+# Point with integers
+
+(10, 20)
+
+==>
+
+SurrealQL(Point(Int,Int))
+
+# Point with floats
+
+(1.5, 2.5)
+
+==>
+
+SurrealQL(Point(Float,Float))

package/test/values/idioms.txt

@@ -0,0 +1,228 @@
+# Dot notation path
+
+$variable.ident.ident
+
+==>
+
+SurrealQL(Path(VariableName,Subscript(Ident),Subscript(Ident)))
+
+# Wildcard on record ID
+
+record:id.*
+
+==>
+
+SurrealQL(Path(RecordId(RecordTbIdent,Colon,RecordIdIdent),Subscript(Any)))
+
+# Lookup arrow right with any
+
+ident->?
+
+==>
+
+SurrealQL(Path(Ident,Lookup(LookupRight,Any)))
+
+# Lookup arrow right
+
+ident->ident
+
+==>
+
+SurrealQL(Path(Ident,Lookup(LookupRight,Ident)))
+
+# Multiple lookups
+
+ident->ident<-ident<->ident
+
+==>
+
+SurrealQL(Path(Ident,Lookup(LookupRight,Ident),Lookup(LookupLeft,Ident),Lookup(LookupBoth,Ident)))
+
+# Record ID lookup
+
+record:id->ident
+
+==>
+
+SurrealQL(Path(RecordId(RecordTbIdent,Colon,RecordIdIdent),Lookup(LookupRight,Ident)))
+
+# SELECT with lookup path
+
+SELECT ->ident FROM ident
+
+==>
+
+SurrealQL(SelectStatement(Keyword,Fields(Predicate(Path(Lookup(LookupRight,Ident)))),Keyword,Ident))
+
+# Method call on number
+
+123.to_string()
+
+==>
+
+SurrealQL(Path(Int,Subscript(IdiomFunction(FunctionName,ArgumentList))))
+
+# Filter with variable key
+
+{}[$variable]
+
+==>
+
+SurrealQL(Path(Object(BraceOpen,BraceClose),Filter("[",VariableName,"]")))
+
+# Filter with ident key
+
+{}[ident]
+
+==>
+
+SurrealQL(Path(Object(BraceOpen,BraceClose),Filter("[",Ident,"]")))
+
+# Filter with string key
+
+{}["string"]
+
+==>
+
+SurrealQL(Path(Object(BraceOpen,BraceClose),Filter("[",String,"]")))
+
+# Record ID filter
+
+record:id[ident]
+
+==>
+
+SurrealQL(Path(RecordId(RecordTbIdent,Colon,RecordIdIdent),Filter("[",Ident,"]")))
+
+# Array index access
+
+[][0]
+
+==>
+
+SurrealQL(Path(Array("[","]"),Filter("[",Int,"]")))
+
+# Array variable access
+
+[][$variable]
+
+==>
+
+SurrealQL(Path(Array("[","]"),Filter("[",VariableName,"]")))
+
+# Array WHERE filter
+
+[][WHERE ident = 123]
+
+==>
+
+SurrealQL(Path(Array("[","]"),Filter("[",WhereClause(Keyword,BinaryExpression(Ident,Operator,Int)),"]")))
+
+# Array question mark filter
+
+[][? ident = 123]
+
+==>
+
+SurrealQL(Path(Array("[","]"),Filter("[",WhereClause(BinaryExpression(Ident,Operator,Int)),"]")))
+
+# Recurse unbounded
+
+person:tobie.{..}->knows->person
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(Recurse(BraceOpen,RecurseRange(RangeOp),RecurseOptions,BraceClose)),
+  Lookup(LookupRight,Ident), Lookup(LookupRight,Ident)
+))
+
+# Recurse with path expression
+
+person:tobie.{..}(->knows->person).name
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(
+    Recurse(
+      BraceOpen, RecurseRange(RangeOp), RecurseOptions, BraceClose,
+      Lookup(LookupRight,Ident), Lookup(LookupRight,Ident)
+    )
+  ),
+  Subscript(Ident)
+))
+
+# Recurse with destructure
+
+person:tobie.{..}.{ id, name, knows: ->knows->person.@ }
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(Recurse(BraceOpen,RecurseRange(RangeOp),RecurseOptions,BraceClose)),
+  Subscript(Destructure(BraceOpen,Ident,Ident,Ident,Colon,Lookup(LookupRight,Ident),Lookup(LookupRight,Ident),Subscript(At),BraceClose))
+))
+
+# Recurse with fixed depth
+
+a:b.{1}
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(Recurse(BraceOpen,RecurseRange(Int),RecurseOptions,BraceClose))
+))
+
+# Recurse with min range
+
+a:b.{1..}
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(Recurse(BraceOpen,RecurseRange(Int,RangeOp),RecurseOptions,BraceClose))
+))
+
+# Recurse with full range
+
+a:b.{1..2}
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(Recurse(BraceOpen,RecurseRange(Int,RangeOp,Int),RecurseOptions,BraceClose))
+))
+
+# Recurse with max range
+
+a:b.{..2}
+
+==>
+
+SurrealQL(Path(
+  RecordId(RecordTbIdent,Colon,RecordIdIdent),
+  Subscript(Recurse(BraceOpen,RecurseRange(RangeOp,Int),RecurseOptions,BraceClose))
+))
+
+# At reference with subscript
+
+@.name
+
+==>
+
+SurrealQL(Path(At,Subscript(Ident)))
+
+# At reference with ident
+
+@name
+
+==>
+
+SurrealQL(Path(At,Ident))

package/test/values/literals.txt

@@ -0,0 +1,46 @@
+# Boolean true
+
+true;
+true
+
+==>
+
+SurrealQL(Bool,Bool)
+
+# Boolean false
+
+false;
+false
+
+==>
+
+SurrealQL(Bool,Bool)
+
+# Null
+
+null;
+null
+
+==>
+
+SurrealQL(None,None)
+
+# None
+
+none;
+none
+
+==>
+
+SurrealQL(None,None)
+
+# Mixed literals
+
+true;
+false;
+null;
+none
+
+==>
+
+SurrealQL(Bool,Bool,None,None)