@xano/xanoscript-language-server 11.12.0 → 11.12.2

package/.claude/memory/feedback_no_git.md

@@ -0,0 +1,11 @@
+---
+name: no-git-interactions
+description: User does not want Claude to interact with git (no commits, no staging, no git commands)
+type: feedback
+---
+
+Do not interact with git — no commits, no staging, no git commands. Focus purely on implementation and testing.
+
+**Why:** User manages their own git workflow.
+
+**How to apply:** Skip all git-related steps in plans. When dispatching subagents, explicitly tell them not to run any git commands. Remove commit steps from task instructions.

package/.claude/settings.local.json

@@ -2,35 +2,20 @@
   "permissions": {
     "allow": [
       "Bash(npm test:*)",
-      "Bash(npm run lint)",
-      "Bash(npm run test:*)",
-      "Bash(npx eslint:*)",
-      "Bash(node:*)",
-      "Bash(npm install)",
+      "Bash(git checkout:*)",
+      "Bash(ls:*)",
+      "Bash(npm run lint:*)",
       "Bash(grep:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --all --pretty=format:\"%h %s\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --all -S \"password\\\\|secret\\\\|api_key\\\\|token\" --oneline)",
-      "Bash(xargs file:*)",
       "Bash(find:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log -p --all -S \"webhook\\\\|Bearer\\\\|discord\\\\|slack\\\\|xano_insiders\" -- \"*.xs\" \"*.js\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server ls-files:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server status)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server diff --stat)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --oneline -5)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server add README.md LICENSE package.json lexer/tests/query/valid_sources/basic_query.xs parser/functions/stream/streamFromRequestFn.js parser/functions/stream/streamFromRequestFn.spec.js parser/tests/function/valid_sources/discord_poll_send_to_slack.xs parser/tests/query/valid_sources/all_basics.xs)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server commit -m \"$\\(cat <<''EOF''\nPrepare package for public npm release as @xano/xanoscript-language-server\n\n- Rename package to @xano/xanoscript-language-server\n- Add MIT LICENSE file\n- Add npm metadata \\(description, repository, author, license, bugs, homepage\\)\n- Remove private flag to allow publishing\n- Sanitize test files: replace internal URLs, IDs, and env var names with placeholders\n- Simplify README maintainer section\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log -1 --oneline)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push)",
-      "Bash(npm whoami:*)",
-      "Bash(npm view:*)",
-      "Bash(npm version:*)",
-      "Bash(npm publish:*)",
-      "Bash(wc:*)",
-      "Bash(git push:*)"
-    ],
-    "deny": [],
-    "ask": []
+      "Read(//tmp/**)",
+      "Bash(git stash:*)",
+      "Bash(do)",
+      "Bash(if ! grep -q \"guidFieldAttribute\" \"$f\")",
+      "Bash(then)",
+      "Bash(echo:*)",
+      "Bash(fi)",
+      "Bash(done)",
+      "Bash(npx eslint:*)"
+    ]
   }
 }

package/lexer/cast.js

@@ -23,14 +23,14 @@ export const BoolCastToken = createUniqToken({
 // !array
 export const ArrayCastToken = createUniqToken({
   name: "ArrayCast",
-  pattern: /!array/,
+  pattern: /!array(?!\.)/,
   label: "!array",
 });
 
 // !text
 export const TextCastToken = createUniqToken({
   name: "TextCast",
-  pattern: /!text/,
+  pattern: /!text(?!\.)/,
   label: "!text",
 });
 
@@ -51,7 +51,7 @@ export const DecimalCastToken = createUniqToken({
 // !object
 export const ObjectCastToken = createUniqToken({
   name: "ObjectCast",
-  pattern: /!object/,
+  pattern: /!object(?!\.)/,
   label: "!object",
 });
 

package/lexer/control.js

@@ -1,5 +1,4 @@
 import { Identifier } from "./identifier.js";
-import { IntegerLiteral } from "./literal.js";
 import { createTokenByName, createUniqToken } from "./utils.js";
 
 // conditional
@@ -173,7 +172,6 @@ export const Minus = createUniqToken({
   name: "Minus",
   pattern: /-/,
   label: "-",
-  longer_alt: IntegerLiteral,
 });
 
 // +

package/lexer/literal.js

@@ -24,13 +24,13 @@ export const SingleQuotedStringLiteral = createUniqToken({
 export const FloatLiteral = createUniqToken({
   name: "FloatLiteral",
   label: "floating point number",
-  pattern: /-?\d+\.\d+([eE][+-]?\d+)?/,
+  pattern: /\d+\.\d+([eE][+-]?\d+)?/,
 });
 
 export const IntegerLiteral = createUniqToken({
   name: "IntegerLiteral",
   label: "integer",
-  pattern: /-?\d+/,
+  pattern: /\d+/,
   longer_alt: FloatLiteral,
 });
 

package/lexer/regexp.spec.js

@@ -0,0 +1,84 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "./lexer.js";
+
+function getTokenTypes(text) {
+  const result = lexDocument(text);
+  return {
+    tokens: result.tokens.map((t) => ({
+      type: t.tokenType.name,
+      image: t.image,
+    })),
+    errors: result.errors,
+  };
+}
+
+describe("RegExpToken lexer", () => {
+  it("should not lex a standalone regex without preceding colon", () => {
+    const { tokens } = getTokenTypes("/[^213]*/");
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+  });
+
+  it("should lex a regex after a colon", () => {
+    const { tokens, errors } = getTokenTypes("pattern:/[^213]*/");
+    expect(errors).to.be.empty;
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(1);
+    expect(regexpTokens[0].image).to.equal("/[^213]*/");
+  });
+
+  it("should lex / as divide after an identifier", () => {
+    const { tokens } = getTokenTypes("var_rel/55");
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+  });
+
+  it("should lex / as divide after a number", () => {
+    const { tokens } = getTokenTypes("55/2");
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+  });
+
+  it("should lex / as divide after closing paren", () => {
+    const { tokens } = getTokenTypes("(1+2)/3");
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should not capture division as regex in complex expressions", () => {
+    const { tokens, errors } = getTokenTypes("$SomeVar.0.var_rel/55");
+    expect(errors).to.be.empty;
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should lex / as divide with spaces around it", () => {
+    const { tokens, errors } = getTokenTypes("$var /64");
+    expect(errors).to.be.empty;
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should lex / as divide with space only before it", () => {
+    const { tokens, errors } = getTokenTypes("$var/ 64");
+    expect(errors).to.be.empty;
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should lex / as divide when no spaces around a value", () => {
+    const { tokens, errors } = getTokenTypes("$var /64/ 34");
+    expect(errors).to.be.empty;
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(2);
+  });
+});

package/lexer/security.js

@@ -51,13 +51,13 @@ export const CreateSecretKeyToken = createTokenByName("create_secret_key", {
 
 // decrypt
 export const DecryptToken = createTokenByName("decrypt", {
-  llt: Identifier,
+  longer_alt: Identifier,
   categories: [Identifier],
 });
 
 // encrypt
 export const EncryptToken = createTokenByName("encrypt", {
-  llt: Identifier,
+  longer_alt: Identifier,
   categories: [Identifier],
 });
 

package/lexer/tokens.js

@@ -1,4 +1,4 @@
-import { Lexer } from "chevrotain";
+import { createToken as chevrotainCreateToken, Lexer } from "chevrotain";
 import { Identifier } from "./identifier.js";
 import {
   createTokenByName,
@@ -150,10 +150,29 @@ export const NullToken = createTokenByName("null", {
 });
 
 // regular expression (regexp) pattern
-export const RegExpToken = createToken({
+// A regexp literal only appears after a colon (e.g., filter:pattern:/[^abc]*/)
+const regexpPattern = /\/(?:[^/\n\\ ]|\\.)(?:[^/\n\\]|\\.)*\//y;
+function matchRegExp(text, startOffset, tokens) {
+  if (
+    tokens.length === 0 ||
+    tokens[tokens.length - 1].tokenType.name !== "ColonToken"
+  ) {
+    return null;
+  }
+  regexpPattern.lastIndex = startOffset;
+  const result = regexpPattern.exec(text);
+  if (result) {
+    return [result[0]];
+  }
+  return null;
+}
+
+export const RegExpToken = chevrotainCreateToken({
   name: "RegExpToken",
   label: "regexp",
-  pattern: /\/(?:[^/\n\\ ]|\\.)(?:[^/\n\\]|\\.)*\//,
+  pattern: { exec: matchRegExp },
+  line_breaks: false,
+  start_chars_hint: ["/"],
 });
 
 export const WhiteSpace = createToken({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.12.0",
+  "version": "11.12.2",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/attributes/columnDefaultValueAttribute.js

@@ -1,4 +1,4 @@
-import { EqualToken } from "../../lexer/control.js";
+import { EqualToken, Minus } from "../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -21,8 +21,15 @@ export function columnDefaultValueAttribute($) {
     $.CONSUME(EqualToken); // "="
     $.OR([
       { ALT: () => $.CONSUME(StringLiteral) }, // e.g., "default value"
-      { ALT: () => $.CONSUME(FloatLiteral) }, // e.g., 42.54
-      { ALT: () => $.CONSUME(IntegerLiteral) }, // e.g., 42
+      {
+        ALT: () => {
+          $.OPTION(() => $.CONSUME(Minus));
+          return $.OR1([
+            { ALT: () => $.CONSUME(IntegerLiteral) },
+            { ALT: () => $.CONSUME(FloatLiteral) },
+          ]);
+        },
+      },
       { ALT: () => $.CONSUME(TrueToken) }, // true
       { ALT: () => $.CONSUME(FalseToken) }, // false
       { ALT: () => $.CONSUME(NowToken) }, // now

package/parser/attributes/inputFilterFn.js

@@ -1,5 +1,5 @@
 import { ExclamationToken } from "../../lexer/cast.js";
-import { ColonToken } from "../../lexer/control.js";
+import { ColonToken, Minus } from "../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -36,8 +36,15 @@ export function inputFilterFn($) {
               { ALT: () => $.CONSUME2(Identifier) },
               { ALT: () => $.CONSUME1(StringLiteral) },
               { ALT: () => $.CONSUME1(RegExpToken) },
-              { ALT: () => $.CONSUME1(IntegerLiteral) },
-              { ALT: () => $.CONSUME1(FloatLiteral) },
+              {
+                ALT: () => {
+                  $.OPTION1(() => $.CONSUME(Minus));
+                  $.OR1([
+                    { ALT: () => $.CONSUME(IntegerLiteral) },
+                    { ALT: () => $.CONSUME(FloatLiteral) },
+                  ]);
+                },
+              },
               { ALT: () => $.CONSUME1(FalseToken) },
               { ALT: () => $.CONSUME1(TrueToken) },
             ]);
@@ -52,7 +59,7 @@ export function inputFilterFn($) {
           ) {
             $.addInvalidValueError(
               filter,
-              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`
+              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`,
             );
           }
         },

package/parser/clauses/flexibleStringClause.js

@@ -1,7 +1,7 @@
 import { EqualToken } from "../../lexer/control.js";
-import { Identifier } from "../../lexer/identifier.js";
 import { StringLiteral } from "../../lexer/literal.js";
 import { MultiLineStringToken } from "../../lexer/multiline.js";
+import { InstructionsToken } from "../../lexer/tool.js";
 
 /**
  * @param {import('../base_parser.js').XanoBaseParser} $
@@ -14,7 +14,7 @@ export function flexibleStringClause($) {
   return (args) => {
     // During parser initialization, args is undefined
     // Use a placeholder token for grammar recording
-    const token = args?.[0] || Identifier;
+    const token = args?.[0] || InstructionsToken;
     const allowEmpty = args?.[1] ?? true;
 
     $.sectionStack.push(token.name + "Clause");

package/parser/clauses/nakedStackFn.js

@@ -20,46 +20,53 @@ export function nakedStackFn($) {
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // required new line before each clause
-      $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+      // $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
       $.OR([
         { ALT: () => $.CONSUME(CommentToken) },
-        { ALT: () => $.SUBRULE($.aiFn) },
-        { ALT: () => $.SUBRULE($.dbFn) },
-        { ALT: () => $.SUBRULE($.varFn) },
-        { ALT: () => $.SUBRULE($.arrayFn) },
-        { ALT: () => $.SUBRULE($.cloudFn) },
-        { ALT: () => $.SUBRULE($.securityFn) },
-        { ALT: () => $.SUBRULE($.mathFn) },
-        { ALT: () => $.SUBRULE($.textFn) },
-        { ALT: () => $.SUBRULE($.utilFn) },
-        { ALT: () => $.SUBRULE($.preconditionFn) },
-        { ALT: () => $.SUBRULE($.zipFn) },
-        { ALT: () => $.SUBRULE($.objectFn) },
-        { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
-        { ALT: () => $.SUBRULE($.webflowFn) },
-        { ALT: () => $.SUBRULE($.redisFn) },
-        { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
-        { ALT: () => $.SUBRULE($.debugFn) },
-        { ALT: () => $.SUBRULE($.storageFn) },
-        { ALT: () => $.SUBRULE($.streamFn) },
-        { ALT: () => $.SUBRULE($.actionCallFn) },
         {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.toolCallFn),
+          ALT: () => {
+            $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+            $.OR1([
+              { ALT: () => $.SUBRULE($.aiFn) },
+              { ALT: () => $.SUBRULE($.dbFn) },
+              { ALT: () => $.SUBRULE($.varFn) },
+              { ALT: () => $.SUBRULE($.arrayFn) },
+              { ALT: () => $.SUBRULE($.cloudFn) },
+              { ALT: () => $.SUBRULE($.securityFn) },
+              { ALT: () => $.SUBRULE($.mathFn) },
+              { ALT: () => $.SUBRULE($.textFn) },
+              { ALT: () => $.SUBRULE($.utilFn) },
+              { ALT: () => $.SUBRULE($.preconditionFn) },
+              { ALT: () => $.SUBRULE($.zipFn) },
+              { ALT: () => $.SUBRULE($.objectFn) },
+              { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
+              { ALT: () => $.SUBRULE($.webflowFn) },
+              { ALT: () => $.SUBRULE($.redisFn) },
+              { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
+              { ALT: () => $.SUBRULE($.debugFn) },
+              { ALT: () => $.SUBRULE($.storageFn) },
+              { ALT: () => $.SUBRULE($.streamFn) },
+              { ALT: () => $.SUBRULE($.actionCallFn) },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.toolCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.addonCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.middlewareCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.triggerCallFn),
+              },
+              { ALT: () => $.SUBRULE($.workflowExpectFn) },
+            ]);
+          },
         },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.addonCallFn),
-        },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.middlewareCallFn),
-        },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.triggerCallFn),
-        },
-        { ALT: () => $.SUBRULE($.workflowExpectFn) },
       ]);
     });
     $.AT_LEAST_ONE2(() => $.CONSUME2(NewlineToken));

package/parser/clauses/nakedStackFn.spec.js

@@ -31,6 +31,16 @@ describe("nakedStack", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("nakedStack accepts a disabled array statement", () => {
+    const parser = parse(`{
+  !array.push $my_array { 
+    value = 1
+  }
+}`);
+    console.log(parser.errors);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("nakedStack accepts a multiline statement", () => {
     const parser = parse(`{
   var $some_var { 

package/parser/clauses/responseClause.spec.js

@@ -27,6 +27,11 @@ describe("responseClause", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("responseClause accepts a string", () => {
+    const parser = parse(`response = "no exception"`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("responseClause accepts an object", () => {
     const parser = parse(`response = {result1: $x1, x2: $x2}`);
     expect(parser.errors).to.be.empty;

package/parser/definitions/columnDefinition.js

@@ -115,7 +115,11 @@ export function columnDefinition($) {
 
     // Track table reference from FK column definition
     if (captured.table?.value) {
-      $.addReference("table", getVarName(captured.table.value), captured.table.value);
+      $.addReference(
+        "table",
+        getVarName(captured.table.value),
+        captured.table.value,
+      );
     }
 
     if (inputTypeToken.image == "vector" && !captured.size) {
@@ -126,7 +130,8 @@ export function columnDefinition($) {
     }
 
     const inTable = $.sectionStack.includes("tableDeclaration");
-    if (captured.visibility && !inTable) {
+    const inIntput = $.sectionStack.includes("inputClause");
+    if (captured.visibility && !inTable && !inIntput) {
       $.addInvalidValueError(
         nameToken,
         'The "visibility" attribute is only valid within a table schema definition.',

package/parser/functions/array/arrayNoValueAs.js

@@ -25,7 +25,7 @@ export function arrayNoValueAs($) {
       $.CONSUME(RCurly);
     });
     $.CONSUME(AsToken);
-    $.SUBRULE($.variableOnly);
+    $.SUBRULE($.assignableVariableAs);
     $.sectionStack.pop();
   };
 }

package/parser/functions/array/arrayPopFn.js

@@ -1,8 +1,6 @@
 import { PopToken } from "../../../lexer/arrays.js";
 
-// array.pop {
-//   value = "test"
-// } as test
+// array.pop $var as $unit
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
  */

package/parser/functions/controls/forEachFn.spec.js

@@ -19,6 +19,14 @@ describe("forEachFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("forEachFn should warn when using a reserved variable name", () => {
+    const parser = parse(`foreach ([]|push:1|push:2|push:3|push:4) {
+      each as $env
+    }`);
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+  });
+
   it("forEachFn can also be foreach.remove", () => {
     const parser = parse(`foreach.remove`);
     expect(parser.errors).to.be.empty;

package/parser/functions/controls/functionRunFn.spec.js

@@ -26,6 +26,16 @@ describe("functionRunFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("functionRunFn accepts complex expression as input", () => {
+    const parser = parse(`function.run "my_complex_function" {
+      input = {
+        Snumber     : (($SomeVar.0.var_rel/55) > 0 ? ($SomeVar.0.var_rel1/61) : 6)+(($My_Var_S2.0.elo/ 60) > 7 ? ($My_Var_S2.0.elo/62) : 9)+(($Optional_var2.0.det/63) > 4 ? ($Optional_var2.0.det /64) : 2)+(($PtSgeS_sge.0.elo/65) > 1 ? ($PtSgeS_sge.0.elo/66) : 3)
+        NumberObject: []
+      }
+    } as $Var_Round`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("functionRunFn accepts a string for function name", () => {
     const parser = parse(`function.run "my/function" {
       input = {a: $input.a, b: $b}

package/parser/functions/controls/preconditionFn.js

@@ -1,4 +1,5 @@
 import { LParent, RParent } from "../../../lexer/control.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
 import { PreconditionToken } from "../../../lexer/util.js";
 
 /**
@@ -13,7 +14,9 @@ export function preconditionFn($) {
     $.sectionStack.push("preconditionFn");
     const tokenFn = $.CONSUME(PreconditionToken); // "precondition"
     $.CONSUME(LParent);
+    $.MANY(() => $.CONSUME(NewlineToken));
     $.SUBRULE($.expressionFn);
+    $.MANY1(() => $.CONSUME1(NewlineToken));
     $.CONSUME(RParent);
     $.SUBRULE($.schemaParseAttributeFn, {
       ARGS: [

package/parser/functions/db/dbExternalDirectQueryFn.js

@@ -14,6 +14,7 @@ export function dbExternalDirectQueryFn($) {
         {
           sql: "[expression]",
           response_type: ["list", "single"],
+          "parser?": "template_engine",
           connection_string: "[expression]",
           "description?": "[string]",
           "disabled?": "[boolean]",

package/parser/functions/db/dbQueryFn.spec.js

@@ -346,4 +346,35 @@ describe("dbQueryFn", () => {
     const parser = parse(`query user as $user`);
     expect(parser.errors).to.be.empty;
   });
+
+  describe("aggregate eval with aggregator pipes", () => {
+    const aggregators = [
+      "avg",
+      "count",
+      "count_distinct",
+      "max",
+      "median",
+      "min",
+      "sum",
+      "to_distinct_list",
+      "to_distinct_list_asc",
+      "to_distinct_list_desc",
+      "to_list",
+      "to_list_asc",
+      "to_list_desc",
+    ];
+
+    for (const agg of aggregators) {
+      it(`dbQueryFn return eval accepts |${agg} aggregator`, () => {
+        const parser = parse(`query user {
+      return = {
+        type: "aggregate"
+        group: {user_name: $db.user.name}
+        eval: {result: $db.user.name|${agg}}
+      }
+    } as $user`);
+        expect(parser.errors).to.be.empty;
+      });
+    }
+  });
 });