@xano/xanoscript-language-server 11.0.3

package/parser/function_parser.js

@@ -0,0 +1,123 @@
+import { CommentToken } from "../lexer/comment.js";
+import { LCurly, RCurly } from "../lexer/control.js";
+import { FunctionToken } from "../lexer/function.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function functionDeclaration($) {
+  return () => {
+    let hasCache = false;
+    let hasDescription = false;
+    let hasDocs = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasMiddleware = false;
+    let hasResponse = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    const testNames = [];
+
+    $.sectionStack.push("functionDeclaration");
+    // Allow leading comments and newlines before the function declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+    const parent = $.CONSUME(FunctionToken);
+    $.OR([
+      { ALT: () => $.CONSUME(Identifier) },
+      { ALT: () => $.CONSUME(StringLiteral) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        { ALT: () => $.CONSUME(CommentToken) },
+        {
+          GATE: () => !hasCache,
+          ALT: () => {
+            hasCache = true;
+            $.SUBRULE($.cacheClause);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasDocs,
+          ALT: () => {
+            hasDocs = true;
+            $.SUBRULE($.docsFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasMiddleware,
+          ALT: () => {
+            hasMiddleware = true;
+            $.SUBRULE($.middlewareClause);
+          },
+        },
+        {
+          GATE: () => !hasResponse,
+          ALT: () => {
+            hasResponse = true;
+            $.SUBRULE($.responseClause);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause);
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+        {
+          // no GATE here, you can have multiple test clauses
+          ALT: () => {
+            $.SUBRULE($.testClause, { ARGS: [testNames] });
+          },
+        },
+      ]);
+    });
+
+    if (!hasInput) {
+      $.addMissingError(parent, "{} is missing an input clause");
+    }
+
+    if (!hasStack) {
+      $.addMissingError(parent, "{} is missing a stack clause");
+    }
+
+    if (!hasResponse) {
+      $.addMissingError(parent, "{} is missing a response clause");
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/function_parser.spec.js

@@ -0,0 +1,83 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("function_parser", () => {
+  it("should parse a basic function", () => {
+    const parser = xanoscriptParser(`function foo {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a function with a test", () => {
+    const parser = xanoscriptParser(`function foo {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+
+      // test cases
+      test "testset " {
+        input = {
+          adoption_application_id: ""
+          user_id                : ""
+          completed_only         : ""
+          scheduled_only         : ""
+          page                   : ""
+          per_page               : ""
+        }
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a basic a function with slashes", () => {
+    const parser = xanoscriptParser(`function "foo/bar" {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a basic a string function url", () => {
+    const parser = xanoscriptParser(`function "foo/bar" {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("function don't accept dynamic params", () => {
+    const parser = xanoscriptParser(`function foo/{user_id} {
+      input {
+        text user_id filters=trim
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/actionCallFn.js

@@ -0,0 +1,41 @@
+import { ActionToken, CallToken } from "../../lexer/action.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function actionCallFn($) {
+  return () => {
+    $.sectionStack.push("actionCallFn");
+    $.CONSUME(ActionToken); // "action"
+    $.CONSUME(DotToken); // "."
+    const fnToken = $.CONSUME(CallToken); // "call"
+
+    $.OR([
+      { ALT: () => $.CONSUME(Identifier) }, // user
+      { ALT: () => $.CONSUME1(StringLiteral) }, // "user/ auth"
+    ]);
+
+    $.OPTION(() => {
+      $.SUBRULE($.schemaParseAttributeFn, {
+        ARGS: [
+          fnToken,
+          {
+            "package?": "[string]",
+            "input?": { "[string]": "[expression]" },
+            "mock?": { "![string]": "[expression]" },
+            "registry?": { "[string]": "[expression]" },
+            "description?": "[string]",
+            "disabled?": "[boolean]",
+          },
+        ],
+      });
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/actionCallFn.spec.js

@@ -0,0 +1,51 @@
+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.actionCallFn();
+  return parser;
+}
+
+describe("actionCallFn", () => {
+  it("should parse action.call statement", () => {
+    const parser = parse(`action.call my_action {
+      input = {
+        "key": "value"
+      }
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should accept a package name", () => {
+    const parser = parse(`action.call my_action {
+      package = "com.example.package"
+      input = {
+        "key": "value"
+      }
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("action.call can be one liner without a body", () => {
+    const parser = parse(`action.call my_action as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("action.call accepts a registry", () => {
+    const parser = parse(`action.call my_agent {
+      input = {
+        "key": "value"
+      }
+      registry = {
+        url: "https://registry.example.com",
+        token: "secrettoken"
+      }
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/addonCallFn.js

@@ -0,0 +1,39 @@
+import { AddonToken, CallToken } from "../../lexer/addon.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function addonCallFn($) {
+  return () => {
+    $.sectionStack.push("addonCallFn");
+    $.CONSUME(AddonToken); // "addon"
+    $.CONSUME(DotToken); // "."
+    const fnToken = $.CONSUME(CallToken); // "call"
+
+    $.OR([
+      { ALT: () => $.CONSUME(Identifier) }, // user
+      { ALT: () => $.CONSUME1(StringLiteral) }, // "user/ auth"
+    ]);
+
+    $.OPTION(() => {
+      $.SUBRULE($.schemaParseAttributeFn, {
+        ARGS: [
+          fnToken,
+          {
+            "input?": { "[string]": "[expression]" },
+            "mock?": { "![string]": "[expression]" },
+            "description?": "[string]",
+            "disabled?": "[boolean]",
+          },
+        ],
+      });
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/addonCallFn.spec.js

@@ -0,0 +1,41 @@
+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.addonCallFn();
+  return parser;
+}
+
+describe("addonCallFn", () => {
+  it("should parse addon.call statement", () => {
+    const parser = parse(`addon.call my_action {
+      input = {
+        "key": "value"
+      }
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse addon.call with a mock", () => {
+    const parser = parse(`addon.call my_action {
+      input = {
+        "key": "value"
+      }
+      mock = {
+        "my test": {result: "mocked_value"}
+        "!disabled test": {result: "mocked_value"}
+      }
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("addon.call can be one liner without a body", () => {
+    const parser = parse(`addon.call my_action as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/ai/aiAgentRunFn.js

@@ -0,0 +1,40 @@
+import { RunToken } from "../../../lexer/ai.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { Identifier } from "../../../lexer/tokens.js";
+
+/**
+ * Handles the run part of ai.agent.run statement
+ * Note: "agent" and "." are already consumed in aiFn
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function aiAgentRunFn($) {
+  return () => {
+    $.sectionStack.push("aiAgentRunFn");
+    const fnToken = $.CONSUME(RunToken); // "run"
+
+    // Agent name can be an identifier or string literal
+    $.OR({
+      DEF: [
+        { ALT: () => $.CONSUME(Identifier) }, // my_agent
+        { ALT: () => $.CONSUME(StringLiteral) }, // "My Agent"
+      ],
+      ERR_MSG: "Expected an agent name",
+    });
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          "args?": "[expression]",
+          "runtime_mode?": ["async-shared", "async-dedicated"],
+          "allow_tool_execution?": "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "version?": "[string]",
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/ai/aiAgentRunFn.spec.js

@@ -0,0 +1,94 @@
+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.aiAgentRunFn();
+  return parser;
+}
+
+describe("aiAgentRunFn", () => {
+  it("should parse ai.agent.run with identifier name", () => {
+    const parser = parse(`run my_first_agent {
+      args = ""
+      allow_tool_execution = true
+    } as $my_first_agent1`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.agent.run with string literal name", () => {
+    const parser = parse(`run "My First Agent" {
+      args = ""
+      allow_tool_execution = true
+    } as $my_first_agent1`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.agent.run with version", () => {
+    const parser = parse(`run "My First Agent" {
+      args = ""
+      allow_tool_execution = true
+      version = "v5"
+    } as $my_first_agent1`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.agent.run with complex args expression", () => {
+    const parser = parse(`run my_agent {
+      args = {}
+        |set:"customer_message":""
+        |set:"messages":([]
+          |push:({}
+            |set:"role":"user"
+            |set:"content":([]
+              |push:({}
+                |set:"type":"text"
+                |set:"text":"What is Xano?"
+              )
+            )
+          )
+        )
+      allow_tool_execution = false
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.agent.run with optional attributes only", () => {
+    const parser = parse(`run my_agent as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.agent.run with disabled attribute", () => {
+    const parser = parse(`run my_agent {
+      disabled = true
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.agent.run with description", () => {
+    const parser = parse(`run my_agent {
+      description = "Run my AI agent"
+      args = ""
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should allow variable expressions for args", () => {
+    const parser = parse(`run my_agent {
+      args = $input.agent_args
+      allow_tool_execution = $input.allow_tools
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error on invalid agent name", () => {
+    const parser = parse(`run 123 {
+      args = ""
+    } as $result`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/ai/aiExternalMcpServerDetailsFn.js

@@ -0,0 +1,28 @@
+import { ServerDetailsToken } from "../../../lexer/ai.js";
+
+/**
+ * Handles server_details part of ai.external.mcp.server_details statement
+ * Note: "external", "mcp" and dots are already consumed in aiFn
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function aiExternalMcpServerDetailsFn($) {
+  return () => {
+    $.sectionStack.push("aiExternalMcpServerDetailsFn");
+    const fnToken = $.CONSUME(ServerDetailsToken); // "server_details"
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          url: "[expression]",
+          bearer_token: "[expression]",
+          connection_type: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/ai/aiExternalMcpServerDetailsFn.spec.js

@@ -0,0 +1,85 @@
+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.aiExternalMcpServerDetailsFn();
+  return parser;
+}
+
+describe("aiExternalMcpServerDetailsFn", () => {
+  it("should parse ai.external.mcp.server_details with required attributes", () => {
+    const parser = parse(`server_details {
+      url = "https://my_mcp/sse"
+      bearer_token = $env.my_secret_key
+      connection_type = "sse"
+    } as $my_mcp_details`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with string literals", () => {
+    const parser = parse(`server_details {
+      url = "https://mcp-server.example.com"
+      bearer_token = "my-secret-token"
+      connection_type = "sse"
+    } as $details`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with variable expressions", () => {
+    const parser = parse(`server_details {
+      url = $input.server_url
+      bearer_token = $env.mcp_token
+      connection_type = $input.connection_type
+    } as $server_info`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with optional description", () => {
+    const parser = parse(`server_details {
+      description = "Get MCP server details"
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+    } as $details`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with disabled flag", () => {
+    const parser = parse(`server_details {
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      disabled = true
+    } as $details`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error when missing required url", () => {
+    const parser = parse(`server_details {
+      bearer_token = $env.token
+      connection_type = "sse"
+    } as $details`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing required bearer_token", () => {
+    const parser = parse(`server_details {
+      url = "https://mcp.example.com"
+      connection_type = "sse"
+    } as $details`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing required connection_type", () => {
+    const parser = parse(`server_details {
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+    } as $details`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/ai/aiExternalMcpToolListFn.js

@@ -0,0 +1,28 @@
+import { ListToken } from "../../../lexer/ai.js";
+
+/**
+ * Handles the list part of ai.external.mcp.tool.list statement
+ * Note: "external", "mcp", "tool" and dots are already consumed in aiFn
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function aiExternalMcpToolListFn($) {
+  return () => {
+    $.sectionStack.push("aiExternalMcpToolListFn");
+    const fnToken = $.CONSUME(ListToken); // "list"
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          url: "[expression]",
+          bearer_token: "[expression]",
+          connection_type: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}