@surrealdb/lezer 1.0.3 → 1.0.5

package/test/statements/transactions.txt

@@ -0,0 +1,47 @@
+# Begin
+
+BEGIN
+
+==>
+
+SurrealQL(BeginStatement(Keyword))
+
+# Begin transaction
+
+BEGIN TRANSACTION
+
+==>
+
+SurrealQL(BeginStatement(Keyword,Keyword))
+
+# Cancel
+
+CANCEL
+
+==>
+
+SurrealQL(CancelStatement(Keyword))
+
+# Cancel transaction
+
+CANCEL TRANSACTION
+
+==>
+
+SurrealQL(CancelStatement(Keyword,Keyword))
+
+# Commit
+
+COMMIT
+
+==>
+
+SurrealQL(CommitStatement(Keyword))
+
+# Commit transaction
+
+COMMIT TRANSACTION
+
+==>
+
+SurrealQL(CommitStatement(Keyword,Keyword))

package/test/statements/update.txt

@@ -0,0 +1,87 @@
+# Simple update
+
+UPDATE person
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident))
+
+# Update ONLY
+
+UPDATE ONLY person:tobie
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Keyword,RecordId(RecordTbIdent,Colon,RecordIdIdent)))
+
+# Update with SET
+
+UPDATE person SET age = 31
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int)))))
+
+# Update with CONTENT
+
+UPDATE person CONTENT {name: "Tobie"}
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,ContentClause(Keyword,Object(BraceOpen,ObjectContent(ObjectProperty(ObjectKey(KeyName),Colon,String)),BraceClose))))
+
+# Update with MERGE
+
+UPDATE person MERGE {age: 31}
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,MergeClause(Keyword,Object(BraceOpen,ObjectContent(ObjectProperty(ObjectKey(KeyName),Colon,Number(Int))),BraceClose))))
+
+# Update with REPLACE
+
+UPDATE person REPLACE {name: "Tobie"}
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,ReplaceClause(Keyword,Object(BraceOpen,ObjectContent(ObjectProperty(ObjectKey(KeyName),Colon,String)),BraceClose))))
+
+# Update with UNSET
+
+UPDATE person UNSET temp = 0
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,UnsetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int)))))
+
+# Update with WHERE
+
+UPDATE person SET age = 31 WHERE name = "Tobie"
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int))),WhereClause(Keyword,BinaryExpression(Ident,Operator,String))))
+
+# Update with RETURN
+
+UPDATE person SET age = 31 RETURN AFTER
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int))),ReturnClause(Keyword,Literal)))
+
+# Update with TIMEOUT
+
+UPDATE person SET age = 31 TIMEOUT 5s
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int))),TimeoutClause(Keyword,Duration(DurationPart))))
+
+# Update with PARALLEL
+
+UPDATE person SET age = 31 PARALLEL
+
+==>
+
+SurrealQL(UpdateStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int))),ParallelClause(Keyword)))

package/test/statements/upsert.txt

@@ -0,0 +1,55 @@
+# Simple upsert
+
+UPSERT person
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Ident))
+
+# Upsert ONLY
+
+UPSERT ONLY person:tobie
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Keyword,RecordId(RecordTbIdent,Colon,RecordIdIdent)))
+
+# Upsert with SET
+
+UPSERT person SET name = "Tobie"
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,String))))
+
+# Upsert with CONTENT
+
+UPSERT person CONTENT {name: "Tobie"}
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Ident,ContentClause(Keyword,Object(BraceOpen,ObjectContent(ObjectProperty(ObjectKey(KeyName),Colon,String)),BraceClose))))
+
+# Upsert with MERGE
+
+UPSERT person MERGE {age: 31}
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Ident,MergeClause(Keyword,Object(BraceOpen,ObjectContent(ObjectProperty(ObjectKey(KeyName),Colon,Number(Int))),BraceClose))))
+
+# Upsert with WHERE
+
+UPSERT person SET age = 31 WHERE name = "Tobie"
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int))),WhereClause(Keyword,BinaryExpression(Ident,Operator,String))))
+
+# Upsert with RETURN
+
+UPSERT person SET age = 31 RETURN AFTER
+
+==>
+
+SurrealQL(UpsertStatement(Keyword,Ident,SetClause(Keyword,FieldAssignment(Ident,Operator,Number(Int))),ReturnClause(Keyword,Literal)))

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("[",Number(Int),"]"))
+
+# Multiple elements
+
+[1, 2, 3]
+
+==>
+
+SurrealQL(Array("[",Number(Int),Number(Int),Number(Int),"]"))
+
+# Trailing comma
+
+[1, 2, 3,]
+
+==>
+
+SurrealQL(Array("[",Number(Int),Number(Int),Number(Int),"]"))
+
+# Nested arrays
+
+[[1, 2], [3, 4]]
+
+==>
+
+SurrealQL(Array("[",Array("[",Number(Int),Number(Int),"]"),Array("[",Number(Int),Number(Int),"]"),"]"))
+
+# Mixed types
+
+[1, "hello", true, null]
+
+==>
+
+SurrealQL(Array("[",Number(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,Number(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,Number(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,Number(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(Number(Int),Operator,Number(Int)),Operator,Number(Int)),BraceClose)))
+
+# Escaped quote in format string
+
+$"some \" quote {1 + 2 + 3} and \{ some } brackets"
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,BinaryExpression(BinaryExpression(Number(Int),Operator,Number(Int)),Operator,Number(Int)),BraceClose)))
+
+# Nested format strings
+
+$'nested {$"string {22}"}'
+
+==>
+
+SurrealQL(FormatString(Interpolation(BraceOpen,FormatString(Interpolation(BraceOpen,Number(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(Number(Decimal),Number(Decimal)))
+
+# Point with integers
+
+(10, 20)
+
+==>
+
+SurrealQL(Point(Number(Int),Number(Int)))
+
+# Point with floats
+
+(1.5, 2.5)
+
+==>
+
+SurrealQL(Point(Number(Float),Number(Float)))