@xano/xanoscript-language-server 11.0.3

package/parser/functions/ai/aiExternalMcpToolListFn.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.aiExternalMcpToolListFn();
+  return parser;
+}
+
+describe("aiExternalMcpToolListFn", () => {
+  it("should parse ai.external.mcp.tool.list with required attributes", () => {
+    const parser = parse(`list {
+      url = "https://www.le_mcp.com/mcp_sse"
+      bearer_token = $env.my_secret_key
+      connection_type = "sse"
+    } as $my_mcp`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with string literals for all fields", () => {
+    const parser = parse(`list {
+      url = "https://my-mcp-server.com/sse"
+      bearer_token = "my-secret-token"
+      connection_type = "sse"
+    } as $mcp_tools`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with variable expressions", () => {
+    const parser = parse(`list {
+      url = $input.mcp_url
+      bearer_token = $input.token
+      connection_type = $input.connection
+    } as $tools`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with optional description", () => {
+    const parser = parse(`list {
+      description = "List MCP tools"
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+    } as $tools`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with disabled flag", () => {
+    const parser = parse(`list {
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      disabled = true
+    } as $tools`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error when missing required url attribute", () => {
+    const parser = parse(`list {
+      bearer_token = $env.token
+      connection_type = "sse"
+    } as $tools`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing required bearer_token attribute", () => {
+    const parser = parse(`list {
+      url = "https://mcp.example.com"
+      connection_type = "sse"
+    } as $tools`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing required connection_type attribute", () => {
+    const parser = parse(`list {
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+    } as $tools`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/ai/aiExternalMcpToolRunFn.js

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

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

@@ -0,0 +1,101 @@
+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.aiExternalMcpToolRunFn();
+  return parser;
+}
+
+describe("aiExternalMcpToolRunFn", () => {
+  it("should parse ai.external.mcp.tool.run with all required attributes", () => {
+    const parser = parse(`run {
+      url = "http://my_mcp.com/sse"
+      bearer_token = $env.my_secret_key
+      connection_type = "sse"
+      tool = "some_tool"
+      args = '{"user_id":123}'
+    } as $api_tool_call`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with variable expressions", () => {
+    const parser = parse(`run {
+      url = $input.mcp_url
+      bearer_token = $env.token
+      connection_type = $input.conn_type
+      tool = "my_tool"
+      args = $input.tool_args
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with object args", () => {
+    const parser = parse(`run {
+      url = "http://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      tool = "my_tool"
+      args = { user_id: 123, name: "test" }
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with optional description", () => {
+    const parser = parse(`run {
+      description = "Execute MCP tool"
+      url = "http://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      tool = "my_tool"
+      args = "{}"
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse with disabled flag", () => {
+    const parser = parse(`run {
+      url = "http://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      tool = "my_tool"
+      args = "{}"
+      disabled = true
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error when missing required url", () => {
+    const parser = parse(`run {
+      bearer_token = $env.token
+      connection_type = "sse"
+      tool = "my_tool"
+      args = "{}"
+    } as $result`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing required tool", () => {
+    const parser = parse(`run {
+      url = "http://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      args = "{}"
+    } as $result`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing required args", () => {
+    const parser = parse(`run {
+      url = "http://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      tool = "my_tool"
+    } as $result`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/ai/register.js

@@ -0,0 +1,24 @@
+import { aiAgentRunFn } from "./aiAgentRunFn.js";
+import { aiExternalMcpServerDetailsFn } from "./aiExternalMcpServerDetailsFn.js";
+import { aiExternalMcpToolListFn } from "./aiExternalMcpToolListFn.js";
+import { aiExternalMcpToolRunFn } from "./aiExternalMcpToolRunFn.js";
+
+/**
+ * Registers all the AI parsers in this folder
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.aiAgentRunFn = $.RULE("aiAgentRunFn", aiAgentRunFn($));
+  $.aiExternalMcpToolListFn = $.RULE(
+    "aiExternalMcpToolListFn",
+    aiExternalMcpToolListFn($)
+  );
+  $.aiExternalMcpToolRunFn = $.RULE(
+    "aiExternalMcpToolRunFn",
+    aiExternalMcpToolRunFn($)
+  );
+  $.aiExternalMcpServerDetailsFn = $.RULE(
+    "aiExternalMcpServerDetailsFn",
+    aiExternalMcpServerDetailsFn($)
+  );
+};

package/parser/functions/aiFn.js

@@ -0,0 +1,61 @@
+import {
+  AgentToken,
+  AiToken,
+  ExternalToken,
+  McpToken,
+  ToolToken,
+} from "../../lexer/ai.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * Handles ai.* statements
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function aiFn($) {
+  return () => {
+    $.sectionStack.push("ai");
+    $.CONSUME(AiToken); // "ai"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      {
+        ALT: () => {
+          $.CONSUME(AgentToken); // "agent"
+          $.CONSUME1(DotToken);
+          $.SUBRULE($.aiAgentRunFn); // "ai.agent.run"
+        },
+      },
+      {
+        ALT: () => {
+          $.CONSUME(ExternalToken); // "external"
+          $.CONSUME2(DotToken); // "."
+          $.CONSUME(McpToken); // "mcp"
+          $.CONSUME3(DotToken); // "."
+
+          $.OR1([
+            {
+              // "ai.external.mcp.server_details"
+              ALT: () => $.SUBRULE($.aiExternalMcpServerDetailsFn),
+            },
+            {
+              ALT: () => {
+                $.CONSUME(ToolToken); // "tool"
+                $.CONSUME4(DotToken); // "."
+                $.OR2([
+                  {
+                    // "ai.external.mcp.tool.list"
+                    ALT: () => $.SUBRULE($.aiExternalMcpToolListFn),
+                  },
+                  {
+                    // "ai.external.mcp.tool.run"
+                    ALT: () => $.SUBRULE($.aiExternalMcpToolRunFn),
+                  },
+                ]);
+              },
+            },
+          ]);
+        },
+      },
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/aiFn.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.aiFn();
+  return parser;
+}
+
+describe("aiFn", () => {
+  it("should parse ai.agent.run statement", () => {
+    const parser = parse(`ai.agent.run my_agent {
+      args = ""
+      allow_tool_execution = true
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.external.mcp.tool.list statement", () => {
+    const parser = parse(`ai.external.mcp.tool.list {
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+    } as $tools`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.external.mcp.tool.run statement", () => {
+    const parser = parse(`ai.external.mcp.tool.run {
+      url = "http://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+      tool = "my_tool"
+      args = "{}"
+    } as $result`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse ai.external.mcp.server_details statement", () => {
+    const parser = parse(`ai.external.mcp.server_details {
+      url = "https://mcp.example.com"
+      bearer_token = $env.token
+      connection_type = "sse"
+    } as $details`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/api/apiCallFn.js

@@ -0,0 +1,49 @@
+import { CallToken } from "../../../lexer/api.js";
+import { EqualToken } from "../../../lexer/control.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import {
+  DELETEToken,
+  GETToken,
+  PATCHToken,
+  POSTToken,
+  PUTToken,
+  VerbToken,
+} from "../../../lexer/query.js";
+import { Identifier } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function apiCallFn($) {
+  return () => {
+    $.sectionStack.push("apiCallFn");
+    const fnToken = $.CONSUME(CallToken); // "call"
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) }, // "foo/bar"
+      { ALT: () => $.CONSUME(Identifier) }, // foo
+    ]);
+    $.CONSUME(VerbToken);
+    $.CONSUME(EqualToken);
+    $.OR1([
+      { ALT: () => $.CONSUME(DELETEToken) },
+      { ALT: () => $.CONSUME(GETToken) },
+      { ALT: () => $.CONSUME(PATCHToken) },
+      { ALT: () => $.CONSUME(POSTToken) },
+      { ALT: () => $.CONSUME(PUTToken) },
+    ]);
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          api_group: "[string]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "headers?": "[expression]",
+          "input?": { "[string]": "[expression]" },
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/api/apiCallFn.spec.js

@@ -0,0 +1,60 @@
+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.apiCallFn();
+  return parser;
+}
+
+describe("apiCallFn", () => {
+  it("apiCallFn accepts url and verb field", () => {
+    const parser = parse(`call foo verb=POST {
+      api_group = "my_api"
+      input = { a: 1}
+    } as $script`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiCallFn accepts interpolated url and verb field", () => {
+    const parser = parse(`call "foo/{foo_id}" verb=POST {
+      api_group = "my_api"
+      input = { foo_id: 1}
+    } as $script`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiCallFn can be disabled", () => {
+    const parser = parse(`call foo verb=PUT {
+      api_group = "my_api"
+      input = { a: 1}
+      disabled = true
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiCallFn accepts a description", () => {
+    const parser = parse(`call foo verb=GET {
+      description = "request function"
+      api_group = "my_api"
+      input = { a: 1}
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiCallFn requires a url and method field", () => {
+    let parser = parse(`request {
+      url = "https://www.example.com"
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`request {
+      method = "GET"
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/api/apiLambdaFn.js

@@ -0,0 +1,19 @@
+import { LambdaToken } from "../../../lexer/api.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function apiLambdaFn($) {
+  const requiredAttrs = ["code", "timeout"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("apiLambdaFn");
+    const fnToken = $.CONSUME(LambdaToken); // "lambda"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/api/apiLambdaFn.spec.js

@@ -0,0 +1,63 @@
+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.apiLambdaFn();
+  return parser;
+}
+
+describe("apiLambdaFn", () => {
+  it("apiLambdaFn accepts data field", () => {
+    const parser = parse(`lambda {
+      timeout = 10
+      code = """
+        console.log("hello world");
+        """
+    } as $script`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiLambdaFn can be disabled", () => {
+    const parser = parse(`lambda {
+      code = """
+        console.log("hello world");
+        """
+      timeout = 10
+      disabled = true
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiLambdaFn can be a single line string", () => {
+    const parser = parse(`lambda {
+      code = 'console.log("hello world");'
+      timeout = 10
+      disabled = true
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiLambdaFn accepts a description", () => {
+    const parser = parse(`lambda {
+      description = "lambda function"
+      code = """
+        console.log("hello world");
+        """
+      timeout = 10
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("apiLambdaFn requires a code field", () => {
+    const parser = parse(`lambda {
+      description = "lambda new user"
+      timeout = 10
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/api/apiRealtimeEventFn.js

@@ -0,0 +1,25 @@
+import { RealtimeEventToken } from "../../../lexer/api.js";
+
+// api.realtime_event {
+//   channel = $env.$http_headers
+//   data = $env.$http_headers
+//   auth_table = "37"
+//   auth_id = $env.my_var
+// }
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function apiRealtimeEventFn($) {
+  const requiredAttrs = ["channel", "data", "auth_table", "auth_id"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("apiRealtimeEventFn");
+    const fnToken = $.CONSUME(RealtimeEventToken); // "realtime_event"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/api/apiRealtimeEventFn.spec.js

@@ -0,0 +1,82 @@
+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.apiRealtimeEventFn();
+  return parser;
+}
+
+describe("apiRealtimeEventFn", () => {
+  it("accepts minimal fieldset", () => {
+    const parser = parse(`realtime_event {
+      channel = "my_users_evt"
+      data = $data_msg
+      auth_table = "37"
+      auth_id = $auth.id
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("can be disabled", () => {
+    const parser = parse(`realtime_event {
+      channel = "my_users_evt"
+      data = $data_msg
+      auth_table = "37"
+      auth_id = $auth.id
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("accepts a description", () => {
+    const parser = parse(`realtime_event {
+      description = "realtime_event {function"
+      channel = "my_users_evt"
+      data = $data_msg
+      auth_table = "37"
+      auth_id = $auth.id
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("requires a channel field", () => {
+    const parser = parse(`realtime_event {
+      data = $data_msg
+      auth_table = "37"
+      auth_id = $auth.id
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("requires a data field", () => {
+    const parser = parse(`realtime_event {
+      channel = "my_users_evt"
+      auth_table = "37"
+      auth_id = $auth.id
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("requires a auth_table field", () => {
+    const parser = parse(`realtime_event {
+      channel = "my_users_evt"
+      data = $data_msg
+      auth_id = $auth.id
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("requires a auth_id field", () => {
+    const parser = parse(`realtime_event {
+      channel = "my_users_evt"
+      data = $data_msg
+      auth_table = "37"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});