@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/parser/definitions/enumColumnDefinition.spec.js

@@ -1,108 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.enumColumnDefinition();
-  return parser;
-}
-
-describe("enumColumnDefinition", () => {
-  it("enumColumnDefinition accepts an array of string values", () => {
-    const parser = parse(`enum variable {
-      values = ["1", "2", "3"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition accepts a default value", () => {
-    const parser = parse(`enum variable?=if_null {
-      values = ["1", "2", "if_null"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition accepts a sensitive marker", () => {
-    const parser = parse(`enum variable {
-      sensitive = true
-      values = ["1", "2", "3"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition accepts a description", () => {
-    const parser = parse(`enum variable {
-      description = "some description goes here"
-      values = ["1", "2", "3"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition adds the enum to the $input registry", () => {
-    const parser = parse(`enum[] variable? {
-      description = "some description goes here"
-      values = ["1", "2", "3"]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-    expect(parser.__symbolTable.input).to.have.property("variable");
-    expect(parser.__symbolTable.input["variable"]).to.deep.equal({
-      type: "enum",
-      iterable: true,
-      nullable: false,
-      optional: true,
-    });
-  });
-
-  it("enumColumnDefinition can have an empty values array", () => {
-    const parser = parse(`enum variable {
-      values = []
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition can be defined as an array of enums", () => {
-    const parser = parse(`enum[] variable {
-      values = ["1", "2", "3"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition can be optional", () => {
-    const parser = parse(`enum variable? {
-      values = ["1", "2", "3"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition cannot start with a number", () => {
-    const parser = parse(`enum 12variable {
-      values = ["1", "2", "3"]
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("enumColumnDefinition can be marked nullable", () => {
-    const parser = parse(`enum? variable {
-      values = ["am", "nullable"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("enumColumnDefinition accepts multiple values in the values array", () => {
-    const parser = parse(`enum order_status? {
-      values = [
-        "draft",
-        "confirmed",
-        "fulfilling",
-        "shipping",
-        "delivered",
-        "returned"
-      ]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/definitions/filterDefinition.spec.js

@@ -1,43 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.filterDefinition();
-  return parser;
-}
-
-describe("filterDefinition", () => {
-  it("filterDefinition accepts a filter", () => {
-    const parser = parse("filters = lower");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterDefinition accepts two filters", () => {
-    const parser = parse("filters = trim | lower");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterDefinition accepts a filter with an argument", () => {
-    const parser = parse("filters = min : 12");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterDefinition can be compact", () => {
-    const parser = parse("filters=min:12");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterDefinition accepts multiple filter with arguments", () => {
-    const parser = parse("filters=min:12|max:50");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterDefinition accepts multiple arguments", () => {
-    const parser = parse("filters=min:12:50");
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/definitions/objectColumnDefinition.spec.js

@@ -1,118 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.objectColumnDefinition();
-  return parser;
-}
-
-describe("objectColumnDefinition", () => {
-  it("objectColumnDefinition accepts a sub schema", () => {
-    const parser = parse(`object variable {
-      schema {
-        int rank
-        object nested {
-          schema {
-            text label
-          }
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectColumnDefinition accepts a sub schema with multiple fields", () => {
-    const parser = parse(`object variable {
-      schema {
-        int rank
-        text label
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectColumnDefinition accepts a description", () => {
-    const parser = parse(`object variable {
-      description = "This is a description"
-      schema {
-        text label
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectColumnDefinition accepts a sensitivity marker", () => {
-    const parser = parse(`object variable {
-      sensitive = true
-      schema {
-        decimal value
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectColumnDefinition can be defined as a list", () => {
-    const parser = parse(`object[] variable {
-      schema {
-        decimal value
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectColumnDefinition can be defined optional", () => {
-    const parser = parse(`object variable? {
-      sensitive = true
-      schema {
-        decimal value
-        bool is_active
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectColumnDefinition cannot be defined nullable", () => {
-    const parser = parse(`object? variable {
-      sensitive = true
-      schema {
-        decimal value
-        bool is_active
-      }
-    }`);
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("objectColumnDefinition adds an input entry", () => {
-    const parser = parse(`object variable? {
-      sensitive = true
-      schema {
-        decimal value
-        bool is_active
-      }
-    }`);
-
-    expect(parser.__symbolTable.input).to.have.property("variable");
-    expect(parser.__symbolTable.input["variable"]).to.deep.equal({
-      type: "enum",
-      iterable: false,
-      nullable: false,
-      optional: true,
-    });
-  });
-
-  it("objectColumnDefinition cannot accept a file", () => {
-    const parser = parse(`object variable? {
-      sensitive = true
-      schema {
-        decimal value
-        file some_file
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/function_parser.spec.js

@@ -1,131 +0,0 @@
-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 raise an error when a function name is empty", () => {
-    const parser = xanoscriptParser(`function "" {
-      input {
-      }
-
-      stack {
-      }
-
-      response = null
-    }`);
-    expect(parser.errors).to.not.be.empty;
-    expect(parser.errors[0].message).to.include("must not be empty");
-  });
-
-  it("should raise an error when a function name starts with /", () => {
-    const parser = xanoscriptParser(`function "/foo" {
-      input {
-      }
-
-      stack {
-      }
-
-      response = null
-    }`);
-    expect(parser.errors).to.not.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;
-  });
-
-  it("should not allow api.call in a function stack", () => {
-    const parser = xanoscriptParser(`function foo {
-      input {
-      }
-
-      stack {
-        group {
-          stack {
-            api.call "users/{user_id}" verb=GET {
-              api_group = "account"
-              input = { user_id: 123 }
-            } as $user
-          }
-        }
-      }
-
-      response = null
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/actionCallFn.spec.js

@@ -1,51 +0,0 @@
-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.spec.js

@@ -1,41 +0,0 @@
-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.spec.js

@@ -1,94 +0,0 @@
-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.spec.js

@@ -1,85 +0,0 @@
-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;
-  });
-});