@xano/xanoscript-language-server 11.7.0 → 11.7.1

package/.claude/settings.local.json

@@ -10,7 +10,9 @@
       "Bash(grep:*)",
       "Bash(node --input-type=module:*)",
       "Bash(find:*)",
-      "Read(//tmp/**)"
+      "Read(//tmp/**)",
+      "Bash(git stash:*)",
+      "Bash(node:*)"
     ]
   }
 }

package/onCompletion/contentAssist.js

@@ -127,6 +127,11 @@ const filterSuggestions = Object.freeze(
   })
 );
 
+// Maximum number of tokens to pass to computeContentAssist.
+// Chevrotain's content assist has exponential complexity with complex grammars;
+// beyond this threshold it can consume gigabytes of memory and OOM the process.
+const MAX_CONTENT_ASSIST_TOKENS = 40;
+
 export function getContentAssistSuggestions(text, scheme) {
   try {
     const lexResult = lexDocument(text);
@@ -138,32 +143,31 @@ export function getContentAssistSuggestions(text, scheme) {
       return filterSuggestions;
     }
 
-    let syntacticSuggestions;
-    parser.reset();
-    if (scheme === "db") {
-      syntacticSuggestions = parser.computeContentAssist(
-        "tableDeclaration",
-        partialTokenVector
-      );
-    } else if (scheme === "api") {
-      syntacticSuggestions = parser.computeContentAssist(
-        "queryDeclaration",
-        partialTokenVector
-      );
-    } else if (scheme === "function") {
-      syntacticSuggestions = parser.computeContentAssist(
-        "functionDeclaration",
-        partialTokenVector
-      );
-    } else if (scheme === "task") {
-      syntacticSuggestions = parser.computeContentAssist(
-        "taskDeclaration",
-        partialTokenVector
-      );
-    } else {
+    // Skip computeContentAssist for large token vectors to prevent OOM.
+    // Chevrotain explores all possible parse paths which grows exponentially
+    // with deeply nested grammars (e.g., arrays inside function blocks).
+    if (partialTokenVector.length > MAX_CONTENT_ASSIST_TOKENS) {
+      return [];
+    }
+
+    const ruleNameByScheme = {
+      db: "tableDeclaration",
+      api: "queryDeclaration",
+      function: "functionDeclaration",
+      task: "taskDeclaration",
+    };
+
+    const ruleName = ruleNameByScheme[scheme];
+    if (!ruleName) {
       return [];
     }
 
+    parser.reset();
+    const syntacticSuggestions = parser.computeContentAssist(
+      ruleName,
+      partialTokenVector
+    );
+
     // The suggestions also include the context, we are only interested
     // in the TokenTypes in this example.
     const tokenTypesSuggestions = syntacticSuggestions

package/package.json

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

package/parser/function_parser.spec.js

@@ -100,10 +100,14 @@ describe("function_parser", () => {
       }
 
       stack {
-        api.call "users/{user_id}" verb=GET {
-          api_group = "account"
-          input = { user_id: 123 }
-        } as $user
+        group {
+          stack {
+            api.call "users/{user_id}" verb=GET {
+              api_group = "account"
+              input = { user_id: 123 }
+            } as $user
+          }
+        }
       }
 
       response = null
@@ -111,4 +115,3 @@ describe("function_parser", () => {
     expect(parser.errors).to.not.be.empty;
   });
 });
-

package/parser/functions/api/apiCallFn.js

@@ -20,15 +20,19 @@ export function apiCallFn($) {
     const fnToken = $.CONSUME(CallToken); // "call"
 
     // Validate that api.call is only used in allowed contexts
-    const validContexts = ["workflowTestDeclaration", "toolDeclaration", "testClause"];
+    const validContexts = [
+      "workflowTestDeclaration",
+      "toolDeclaration",
+      "testClause",
+    ];
     const isInValidContext = validContexts.some((context) =>
-      $.sectionStack.includes(context)
+      $.sectionStack.includes(context),
     );
 
     if (!isInValidContext) {
       $.addInvalidValueError(
         fnToken,
-        "api.call can only be used within workflow_test, tool, or test contexts"
+        "api.call can only be used within workflow_test, tool, or test contexts",
       );
     }
 

package/parser/functions/expect/unitExpectToBeWithinFn.spec.js

@@ -29,8 +29,10 @@ describe("unitExpectToBeWithinFn", () => {
   });
 
   it("unitExpectToBeWithinFn does not accepts filters on value argument", () => {
-    const parser =
-      parse(`to_be_within (($response|get:foo:"bar")|first|concat:bar) {
+    const parser = parse(`to_be_within (($response|get:foo:"bar")
+        |first
+        |concat:bar
+      ) {
       min = 11
       max = 13
     }`);

package/parser/functions/expect/unitExpectWithArgumentsFn.js

@@ -10,7 +10,10 @@ import {
   ToStartWithToken,
 } from "../../../lexer/expect.js";
 import { DotToken, Identifier } from "../../../lexer/tokens.js";
-import { ResponseVariable } from "../../../lexer/variables.js";
+import {
+  ResponseVariable,
+  ShortFormVariable,
+} from "../../../lexer/variables.js";
 
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
@@ -32,7 +35,10 @@ export function unitExpectWithArgumentsFn($) {
     $.CONSUME(ResponseVariable); // "$response"
     $.MANY(() => {
       $.CONSUME(DotToken); // "."
-      $.CONSUME(Identifier); // "x", "users", etc.
+      $.OR1([
+        { ALT: () => $.CONSUME(Identifier) }, // "x", "users", etc.
+        { ALT: () => $.CONSUME(ShortFormVariable) }, // "$xyz"
+      ]);
     });
     $.CONSUME(RParent); // ")"
 

package/parser/functions/expect/unitExpectWithArgumentsFn.spec.js

@@ -20,6 +20,13 @@ describe("unitExpectWithArgumentsFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("unitExpectWithArgumentsFn to_equal accepts a $response subpath with $ prefix", () => {
+    const parser = parse(`to_equal ($response.$xyz) {
+      value = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("unitExpectWithArgumentsFn does not accept a non response variable", () => {
     const parser = parse(`to_equal ($foo) {
       value = 12  

package/parser/functions/expect/workflowExpectToBeWithinFn.js

@@ -1,5 +1,6 @@
 import { LParent, RParent } from "../../../lexer/control.js";
 import { ToBeWithinToken } from "../../../lexer/expect.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
 
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
@@ -13,6 +14,7 @@ export function workflowExpectToBeWithinFn($) {
     const fnToken = $.CONSUME(ToBeWithinToken); // "to_be_within"
     $.CONSUME(LParent); // "("
     $.SUBRULE($.expressionFn); // "$foo|get:bar:null"
+    $.MANY(() => $.CONSUME(NewlineToken)); // allow newlines between the expression and the attributes
     $.CONSUME(RParent); // ")"
     $.SUBRULE($.functionAttrReq, {
       ARGS: [fnToken, requiredAttrs, optionalAttrs],

package/parser/functions/expect/workflowExpectWithArgumentsFn.js

@@ -9,6 +9,7 @@ import {
   ToNotEqualToken,
   ToStartWithToken,
 } from "../../../lexer/expect.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
 
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
@@ -31,6 +32,7 @@ export function workflowExpectWithArgumentsFn($) {
     ]);
     $.CONSUME(LParent); // "("
     $.SUBRULE($.expressionFn); // "$foo|get:bar:null"
+    $.MANY(() => $.CONSUME(NewlineToken)); // allow newlines between the expression and the attributes
     $.CONSUME(RParent); // ")"
     $.SUBRULE($.functionAttrReq, {
       ARGS: [fnToken, requiredAttrs, optionalAttrs],

package/parser/functions/expect/workflowExpectWithArgumentsFn.spec.js

@@ -27,6 +27,13 @@ describe("workflowExpectWithArgumentsFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("accept string a named attribute", () => {
+    const parser = parse(`to_equal ($attr.sub."some value") {
+      value = "enabled"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("workflowExpectWithArgumentsFn accepts a filtered variable", () => {
     // foo is not in quotes
     let parser = parse(`to_equal ($x|get:foo:"bar") {

package/parser/functions/expect/workflowExpectWithoutArgumentsFn.js

@@ -10,6 +10,7 @@ import {
   ToNotBeDefinedToken,
   ToNotBeNullToken,
 } from "../../../lexer/expect.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
 
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
@@ -30,6 +31,7 @@ export function workflowExpectWithoutArgumentsFn($) {
     ]);
     $.CONSUME(LParent); // "("
     $.SUBRULE($.expressionFn); // "$foo|get:bar:null"
+    $.MANY(() => $.CONSUME(NewlineToken)); // allow newlines between the expression and the attributes
     $.CONSUME(RParent); // ")"
     $.SUBRULE($.functionAttrReq, {
       ARGS: [fnToken, [], ["description", "disabled"]],

package/parser/functions/schema/schemaFn.js

@@ -64,7 +64,7 @@ export function schemaFn($) {
             schemaExpectOneOf(
               schema,
               ["string", "number", "boolean", "timestamp"],
-              captured
+              captured,
             ),
           ALT: () => {
             $.SUBRULE($.schemaParseImmutableFn, {

package/parser/functions/schema/schemaParseAttributeFn.spec.js

@@ -14,7 +14,7 @@ export function parserExtension() {
       const name = this.CONSUME(Identifier);
       this.CONSUME(EqualToken); // "="
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   this.schemaParseAttributeFn_expression = this.RULE(
@@ -26,7 +26,7 @@ export function parserExtension() {
       };
       const name = this.CONSUME(Identifier);
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   // this rule requires a foo field to be defined
@@ -36,7 +36,7 @@ export function parserExtension() {
       const schema = { "disabled?": "[boolean]", "description?": "[string]" };
       const name = this.CONSUME(Identifier);
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   this.schemaParseAttributeFn_deep = this.RULE(
@@ -52,7 +52,7 @@ export function parserExtension() {
       const name = this.CONSUME(Identifier);
       this.CONSUME(EqualToken); // "="
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   this.schemaParseAttributeFn_stack = this.RULE(
@@ -65,7 +65,7 @@ export function parserExtension() {
       };
       const name = this.CONSUME(Identifier);
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   this.schemaParseAttributeFn_optional = this.RULE(
@@ -80,7 +80,7 @@ export function parserExtension() {
       const name = this.CONSUME(Identifier);
       this.CONSUME(EqualToken); // "="
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   this.schemaParseAttributeFn_multiple = this.RULE(
@@ -93,7 +93,7 @@ export function parserExtension() {
       const name = this.CONSUME(Identifier);
       this.CONSUME(EqualToken); // "="
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 
   this.schemaParseAttributeFn_disabled = this.RULE(
@@ -108,7 +108,7 @@ export function parserExtension() {
       const name = this.CONSUME(Identifier);
       this.CONSUME(EqualToken); // "="
       this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
-    }
+    },
   );
 }
 
@@ -133,7 +133,7 @@ describe("schemaParseAttributeFn", () => {
     expect(parser.errors).to.be.empty;
 
     parse(
-      `value = { something = 123.2, other_thing = 44 }`
+      `value = { something = 123.2, other_thing = 44 }`,
     ).schemaParseAttributeFn_flat();
     expect(parser.errors).to.be.empty;
   });

package/parser/functions/workflowExpectFn.js

@@ -12,13 +12,13 @@ export function workflowExpectFn($) {
     // Validate that expect statements are only used in allowed contexts
     const validContexts = ["workflowTestDeclaration", "testClause"];
     const isInValidContext = validContexts.some((context) =>
-      $.sectionStack.includes(context)
+      $.sectionStack.includes(context),
     );
 
     if (!isInValidContext) {
       $.addInvalidValueError(
         expectToken,
-        "expect statements can only be used within workflow_test or test contexts"
+        "expect statements can only be used within workflow_test or test contexts",
       );
     }
 

package/parser/functions/workflowExpectFn.spec.js

@@ -0,0 +1,33 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.sectionStack.push("workflowTestDeclaration");
+  parser.workflowExpectFn();
+  return parser;
+}
+
+describe("workflowExpectFn", () => {
+  it("workflowExpectFn accepts a string literal as value", () => {
+    const parser = parse(`expect.to_equal ($response.email) {
+      value = "email@example.com"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectFn accepts filtered values", () => {
+    const parser = parse(`expect.to_equal ($total
+      |subtract:$tax
+      |subtract:$cost
+    ) {
+      value = $som_value
+    }`);
+    console.log(parser.errors);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/chainedIdentifier.js

@@ -1,4 +1,4 @@
-import { IntegerLiteral } from "../../lexer/literal.js";
+import { IntegerLiteral, StringLiteral } from "../../lexer/literal.js";
 import { DotToken, Identifier } from "../../lexer/tokens.js";
 import { ShortFormVariable } from "../../lexer/variables.js";
 
@@ -38,6 +38,7 @@ export function singleChainedIdentifier($) {
             }, // e.g., .bar
             { ALT: () => $.CONSUME(Identifier) }, // e.g., .bar
             { ALT: () => $.CONSUME2(IntegerLiteral) }, // e.g., .3
+            { ALT: () => $.CONSUME(StringLiteral) }, // e.g., ."some value"
             { ALT: () => $.SUBRULE($.bracketAccessor) }, // e.g., .["key"]
           ]);
         },

package/parser/parser.js

@@ -15,6 +15,7 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
     scheme = getSchemeFromContent(text);
   }
   const lexResult = preTokenized || lexDocument(text);
+  parser.reset();
   parser.input = lexResult.tokens;
   switch (scheme.toLowerCase()) {
     case "addon":

package/parser/workflow_test_parser.js

@@ -45,9 +45,7 @@ export function workflowTestDeclaration($) {
           ALT: () => {
             hasStack = true;
             $.SUBRULE($.stackClause, {
-              ARGS: [
-                { allowCallStatements: true },
-              ],
+              ARGS: [{ allowCallStatements: true }],
             });
           },
         },

package/parser/workflow_test_parser.spec.js

@@ -39,8 +39,10 @@ describe("workflow_test_parser", () => {
           input = {a: 5, b: 10}
         } as $sums
       
-        expect.to_equal ($sum) {
-          value = 15
+        expect.to_equal ($sum
+          |subtract:5
+        ) {
+          value = 10
         }
       }
     }`);
@@ -95,6 +97,10 @@ describe("workflow_test_parser", () => {
           value = 42
         }
 
+        function.run woot {
+          input = {scope: 12}
+        } as $my_val
+
         group {
           stack {
             function.call "add" {
@@ -113,6 +119,11 @@ describe("workflow_test_parser", () => {
               input = {a: 20, b: 22}
             } as $sum
              
+            api.call "users/{user_id}" verb=GET {
+              api_group = "account"
+              input = { user_id: 123 }
+            } as $user
+
             expect.to_equal ($a) {
               value = 42
             }