@xano/xanoscript-language-server 11.12.2 → 12.0.0

package/parser/clauses/channelClause.spec.js

@@ -1,34 +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.channelClause();
-  return parser;
-}
-
-describe("channelClause", () => {
-  it("channelClause accepts string", () => {
-    const parser = parse(`channel = "test"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("channelClause doesn't allow empty string with double quotes", () => {
-    const parser = parse(`channel = ""`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("channelClause doesn't allow empty string with single quotes", () => {
-    const parser = parse(`channel = ''`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("channelClause only allows strings (not numerical)", () => {
-    const parser = parse(`channel = '123'`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/clauses/dbTableClause.spec.js

@@ -1,34 +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.dbTableClause();
-  return parser;
-}
-
-describe("dbTableClause", () => {
-  it("dbTableClause accepts string", () => {
-    const parser = parse(`table = "test"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("dbTableClause doesn't allow empty string with double quotes", () => {
-    const parser = parse(`table = ""`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("dbTableClause doesn't allow empty string with single quotes", () => {
-    const parser = parse(`table = ''`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("dbTableClause only allows strings (not numerical)", () => {
-    const parser = parse(`table = '123'`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/clauses/historyClause.spec.js

@@ -1,53 +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.historyClause();
-  return parser;
-}
-
-describe("historyClause", () => {
-  it("historyClause can be disabled", () => {
-    const parser = parse(`history = false`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("historyClause accepts a limit", () => {
-    let parser = parse(`history = 0`);
-    expect(parser.errors).to.be.empty;
-    parser = parse(`history = 10`);
-    expect(parser.errors).to.be.empty;
-    parser = parse(`history = 12`);
-    expect(parser.errors).to.not.be.empty;
-    parser = parse(`history = 100`);
-    expect(parser.errors).to.be.empty;
-    parser = parse(`history = 1000`);
-    expect(parser.errors).to.be.empty;
-    parser = parse(`history = 10000`);
-    expect(parser.errors).to.be.empty;
-    parser = parse(`history = 100000`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("historyClause can be inherited", () => {
-    const parser = parse(`history = "inherit"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("historyClause accepts all", () => {
-    let parser = parse(`history = "all"`);
-    expect(parser.errors).to.be.empty;
-
-    parser = parse(`history = all`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("historyClause does not accept a limit that is not a valid number", () => {
-    const parser = parse(`history = 1234`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/clauses/indexClause.spec.js

@@ -1,47 +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.indexClause();
-  return parser;
-}
-
-describe("indexClause", () => {
-  it("indexClause accepts many indices", () => {
-    const parser = parse(`index = [
-    {type: "primary", field: [{name: "id"}]}
-    {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-    {type: "btree", field: [{name: "created_at", op: "desc"}]}
-    {
-      type : "vector"
-      field: [{name: "name_vector", op: "vector_ip_ops"}]
-    }
-  ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("indexClause accepts one index", () => {
-    const parser = parse(`index = [
-    {type: "primary", field: [{name: "id"}]}
-  ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("indexClause accepts single and multiline indices", () => {
-    const parser = parse(`index = [
-    {type: "primary", field: [{name: "id"}]}
-    {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-    {
-      type : "btree"
-      field: [
-        {name: "meeting_id", op: "asc"}
-        {name: "member_id", op: "asc"}
-      ]
-    }
-  ]`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/inputClause.spec.js

@@ -1,96 +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.inputClause();
-  return parser;
-}
-
-describe("inputClause", () => {
-  it("inputClause accepts empty input", () => {
-    const parser = parse(`input {}`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause accepts a single input as one liner", () => {
-    const parser = parse(`input { email email_input? filters=trim|lower }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause cannot have 2 statement on the same line", () => {
-    const parser = parse(
-      `input { email email_input? filters=trim|lower text name }`,
-    );
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("inputClause accepts filters and field definition", () => {
-    const parser = parse(`input {
-    email email_input? filters=trim|lower
-  }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause can be empty", () => {
-    const parser = parse(`input`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause field accepts a description as a comment", () => {
-    const parser = parse(`input {
-        // this is a label
-        text label
-
-        // another comment
-        int rank
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause accepts a description", () => {
-    const parser = parse(`input {
-        text label {
-          description = "This is a description"
-        }
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause field accepts a sensitivity marker", () => {
-    const parser = parse(`input {
-        decimal value {
-          sensitive = true
-        }
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause field accepts a file type", () => {
-    const parser = parse(`input {
-        dblink {
-          table = "book_club_meeting_registration"
-        }
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause field accepts dblink definition", () => {
-    const parser = parse(`input {
-        file my_file?
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputClause accepts multiple fields", () => {
-    const parser = parse(`input {
-            int rank
-            text label
-          }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/mcpServerClause.spec.js

@@ -1,34 +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.mcpServerClause();
-  return parser;
-}
-
-describe("mcpServerClause", () => {
-  it("mcpServerClause accepts string", () => {
-    const parser = parse(`mcp_server = "test"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("mcpServerClause doesn't allow empty string with double quotes", () => {
-    const parser = parse(`mcp_server = ""`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("mcpServerClause doesn't allow empty string with single quotes", () => {
-    const parser = parse(`mcp_server = ''`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("mcpServerClause only allows strings (not numerical)", () => {
-    const parser = parse(`mcp_server = '123'`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/clauses/middlewareClause.spec.js

@@ -1,161 +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.middlewareClause();
-  return parser;
-}
-
-describe("middlewareClause", () => {
-  it("middlewareClause accepts empty pre", () => {
-    const parser = parse(`middleware = {
-      pre: []
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts empty post", () => {
-    const parser = parse(`middleware = {
-      post: []
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts both pre and post", () => {
-    const parser = parse(`middleware = {
-      pre: []
-      post: []
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts pre with single middleware object", () => {
-    const parser = parse(`middleware = {
-      pre: [{
-        name: "auth_middleware"
-      }]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts post with single middleware object", () => {
-    const parser = parse(`middleware = {
-      post: [{
-        name: "logging_middleware"
-      }]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts pre with multiple middleware objects", () => {
-    const parser = parse(`middleware = {
-      pre: [
-        {name: "auth_middleware"}
-        {name: "validation_middleware"}
-      ]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts middleware with required attribute", () => {
-    const parser = parse(`middleware = {
-      pre: [{
-        name: "auth_middleware"
-        required: true
-      }]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts middleware with required set to false", () => {
-    const parser = parse(`middleware = {
-      pre: [{
-        name: "optional_middleware"
-        required: false
-      }]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts complex configuration with both pre and post", () => {
-    const parser = parse(`middleware = {
-      pre: [
-        {name: "auth_middleware", required: true}
-        {name: "rate_limiter", required: false}
-      ]
-      post: [
-        {name: "logging_middleware"}
-      ]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts middleware object with only name", () => {
-    const parser = parse(`middleware = {
-      pre: [{
-        name: "auth_middleware"
-      }]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause accepts middleware with both attributes using colon syntax", () => {
-    const parser = parse(`middleware = {
-      pre: [{name: "auth_middleware", required: true}]
-    }`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause rejects unknown attributes at top level", () => {
-    const parser = parse(`middleware = {
-      pre: []
-      unknown = true
-    }`);
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("middlewareClause accepts middleware with multiline formatting", () => {
-    const parser = parse(`middleware = {
-      pre: [
-        {
-          name: "auth_middleware"
-          required: true
-        }
-        {
-          name: "validation_middleware"
-          required: false
-        }
-      ]
-      post: [
-        {
-          name: "logging_middleware"
-        }
-      ]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("middlewareClause cannot accepts empty middleware block", () => {
-    const parser = parse(`middleware = {
-    }`);
-
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/clauses/nakedStackFn.spec.js

@@ -1,73 +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.nakedStackFn();
-  return parser;
-}
-
-describe("nakedStack", () => {
-  it("nakedStack accepts as single statement", () => {
-    const parser = parse(`{
-  var $some_var { 
-    value = "value"
-  }
-}`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("nakedStack accepts a disabled statement", () => {
-    const parser = parse(`{
-  !var $some_var { 
-    value = "value"
-  }
-}`);
-
-    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 { 
-    value = "value"
-  }
-
-  var.update $some_var { 
-    value = "value2"
-  }
-}`);
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("nakedStack accepts a multiline comments", () => {
-    const parser = parse(`{
-  var $some_var { 
-    value = "value"
-  }
-
-  // Comment here
-  // Another comment
-  
-  var.update $some_var { 
-    value = "value2"
-  }
-}`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/responseClause.spec.js

@@ -1,47 +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.responseClause();
-  return parser;
-}
-
-describe("responseClause", () => {
-  it("responseClause accepts a variable value", () => {
-    const parser = parse(`response = $x1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("responseClause accepts a variable value with a filter", () => {
-    const parser = parse(`response = $x1|trim`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("responseClause accepts a boolean value", () => {
-    const parser = parse(`response = true`);
-    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;
-  });
-
-  it("responseClause accepts multiple line object", () => {
-    const parser = parse(`response = {
-      result1: $x1
-      x2: $x2
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/scheduleClause.spec.js

@@ -1,71 +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.scheduleClause();
-  return parser;
-}
-
-describe("scheduleClause", () => {
-  it("scheduleClause accepts an empty event", () => {
-    const parser = parse(`schedule = []`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("scheduleClause accepts a start time alone", () => {
-    const parser = parse(`schedule = [
-      {starts_on: 2025-03-17 18:33:50+0000}
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("scheduleClause reject a schedule without a start time", () => {
-    const parser = parse(`schedule = [
-      {ends_on: 2025-03-17 18:33:50+0000, freq: 172800}
-    ]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("scheduleClause accepts a start time and frequency", () => {
-    const parser = parse(`schedule = [
-      {starts_on: 2025-03-17 18:33:55+0000, freq: 172800}
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("scheduleClause requires a commas when time is defined on a single line", () => {
-    const parser = parse(`schedule = [
-      {starts_on: 2025-03-17 18:33:55+0000 freq: 172800}
-    ]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("scheduleClause accepts a start time, frequency, and end time", () => {
-    const parser = parse(`schedule = [
-      {
-        starts_on: 2025-03-17 18:34:02+0000
-        freq: 604800
-        ends_on: 2029-03-15 18:34:02+0000
-      }
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("scheduleClause accepts multiple times", () => {
-    const parser = parse(`schedule = [
-      {starts_on: 2025-03-17 18:33:50+0000}
-      {starts_on: 2025-03-17 18:33:55+0000, freq: 172800}
-      {
-        starts_on: 2025-03-17 18:34:02+0000
-        freq: 604800
-        ends_on: 2029-03-15 18:34:02+0000
-      }
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-});