@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/parser/attributes/descriptionFieldAttribute.spec.js

@@ -1,39 +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.descriptionFieldAttribute();
-  return parser;
-}
-
-describe("descriptionFieldAttribute", () => {
-  it("descriptionFieldAttribute accepts a string literal", () => {
-    const parser = parse('description = "some description goes here"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("descriptionFieldAttribute rejects identifier", () => {
-    const parser = parse("description = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("descriptionFieldAttribute rejects digit", () => {
-    const parser = parse("description = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("descriptionFieldAttribute can be compact", () => {
-    const parser = parse('description="another description"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("descriptionFieldAttribute does not require a new line", () => {
-    const parser = parse('description="some description"');
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/disabledFieldAttribute.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.disabledFieldAttribute();
-  return parser;
-}
-
-describe("disabledFieldAttribute", () => {
-  it("disabledFieldAttribute accepts a boolean", () => {
-    const parser = parse("disabled = true");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("disabledFieldAttribute rejects identifier", () => {
-    const parser = parse("disabled = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("disabledFieldAttribute rejects digit", () => {
-    const parser = parse("disabled = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("disabledFieldAttribute can be compact", () => {
-    const parser = parse('disabled=false"');
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/docsFieldAttribute.spec.js

@@ -1,44 +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.docsFieldAttribute();
-  return parser;
-}
-
-describe("docsFieldAttribute", () => {
-  it("docsFieldAttribute accepts a string literal", () => {
-    const parser = parse('docs = "some docs goes here"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("docsFieldAttribute rejects identifier", () => {
-    const parser = parse("docs = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("docsFieldAttribute rejects digit", () => {
-    const parser = parse("docs = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("docsFieldAttribute can be compact", () => {
-    const parser = parse('docs="another docs"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("docsFieldAttribute can be multiline", () => {
-    const parser = parse('docs="""\nanother docs\n"""');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("docsFieldAttribute does not require a new line", () => {
-    const parser = parse('docs="some docs"');
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/guidFieldAttribute.spec.js

@@ -1,93 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { xanoscriptParser } from "../parser.js";
-
-describe("guidFieldAttribute", () => {
-  it("should parse guid in a table", () => {
-    const parser = xanoscriptParser(`table "foo" {
-      guid = "tgGYuUFKbBz4_6DIkDR5hUUCRno"
-      auth = false
-      schema {
-        int id
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should parse guid in a function", () => {
-    const parser = xanoscriptParser(`function "my/function" {
-      guid = "dg4egGY_sadclkj231af32"
-      input {
-      }
-      stack {
-      }
-      response = null
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should parse guid in a query", () => {
-    const parser = xanoscriptParser(`query "test" verb = GET {
-      guid = "abc123def456"
-      api_group = "default"
-      input {
-      }
-      stack {
-      }
-      response = null
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should parse guid in a task", () => {
-    const parser = xanoscriptParser(`task "my_task" {
-      guid = "task_guid_123"
-      stack {
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should parse guid in an api_group", () => {
-    const parser = xanoscriptParser(`api_group "my_group" {
-      guid = "api_group_guid_123"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should parse guid in a middleware", () => {
-    const parser = xanoscriptParser(`middleware "my_mw" {
-      guid = "mw_guid_123"
-      input {
-      }
-      stack {
-      }
-      response = null
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should not allow duplicate guid", () => {
-    const parser = xanoscriptParser(`function "test" {
-      guid = "first"
-      guid = "second"
-      input {
-      }
-      stack {
-      }
-      response = null
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("should work without guid (optional)", () => {
-    const parser = xanoscriptParser(`function "test" {
-      input {
-      }
-      stack {
-      }
-      response = null
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/inputFilterFn.spec.js

@@ -1,39 +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.inputFilterFn();
-  return parser;
-}
-
-describe("inputFilterFn", () => {
-  it("inputFilterFn can reference registered filters", () => {
-    const parser = parse("trim");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputFilterFn accepts an argument", () => {
-    const parser = parse("max:12");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputFilterFn accepts regexp arguments", () => {
-    const parser = parse("pattern:/[^213]*/");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputFilterFn accepts many args", () => {
-    const parser = parse("prevent:foo:bar");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("inputFilterFn accepts dbo link", () => {
-    const parser = parse("@:dbo=12");
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/sensitiveFieldAttribute.spec.js

@@ -1,39 +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.sensitiveFieldAttribute();
-  return parser;
-}
-
-describe("sensitiveFieldAttribute", () => {
-  it("sensitiveFieldAttribute accepts a true value", () => {
-    const parser = parse("sensitive = true");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("sensitiveFieldAttribute accepts a true value", () => {
-    const parser = parse("sensitive = false");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("sensitiveFieldAttribute rejects anything else", () => {
-    const parser = parse("sensitive = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("sensitiveFieldAttribute rejects digit", () => {
-    const parser = parse("sensitive = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("sensitiveFieldAttribute can be compact", () => {
-    const parser = parse("sensitive=true");
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/valueFieldAttribute.spec.js

@@ -1,54 +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.valueFieldAttribute();
-  return parser;
-}
-
-describe("valueFieldAttribute", () => {
-  it("valueFieldAttribute accepts a string literal", () => {
-    const parser = parse('value = "some value goes here"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute accepts a digit", () => {
-    const parser = parse("value = 123");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute accepts a float", () => {
-    const parser = parse("value = 12.3");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute accepts a boolean", () => {
-    const parser = parse("value = false");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute accepts a variable", () => {
-    const parser = parse("value = $variable");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute can be compact", () => {
-    const parser = parse('value="another value"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute does not require a new line", () => {
-    const parser = parse('value="some value"');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valueFieldAttribute rejects identifier", () => {
-    const parser = parse("value = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/attributes/valuesFieldAttribute.spec.js

@@ -1,44 +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.valuesFieldAttribute();
-  return parser;
-}
-
-describe("valuesFieldAttribute", () => {
-  it("valuesFieldAttribute accepts a string literal", () => {
-    const parser = parse('values = [ "some", "values" ]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valuesFieldAttribute accepts multiple line feeds", () => {
-    const parser = parse('values = [ "some", "values" ]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valuesFieldAttribute rejects identifier", () => {
-    const parser = parse("values = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("valuesFieldAttribute rejects digit", () => {
-    const parser = parse("values = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("valuesFieldAttribute can be compact", () => {
-    const parser = parse('values=["another","description"]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("valuesFieldAttribute does not requires a new line", () => {
-    const parser = parse('values = [ "some", "values" ]');
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/attributes/visibilityFieldAttribute.spec.js

@@ -1,44 +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.visibilityFieldAttribute();
-  return parser;
-}
-
-describe("visibilityFieldAttribute", () => {
-  it("visibilityFieldAttribute accepts a private value", () => {
-    const parser = parse(`visibility = "private"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("visibilityFieldAttribute accepts an internal value", () => {
-    const parser = parse(`visibility = "internal"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("visibilityFieldAttribute accepts a public value", () => {
-    const parser = parse(`visibility = "public"`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("visibilityFieldAttribute rejects anything else", () => {
-    const parser = parse(`visibility = "something"`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("visibilityFieldAttribute rejects digit", () => {
-    const parser = parse("visibility = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("visibilityFieldAttribute can be compact", () => {
-    const parser = parse(`visibility="private"`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/branch_parser.spec.js

@@ -1,34 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { xanoscriptParser } from "./parser.js";
-
-describe("branch_parser", () => {
-  it("should parse a complete branch with identifier", () => {
-    const parser = xanoscriptParser(`// This is the original branch.
-  branch v1 {
-    color = "#fff3cd"
-    middleware = {
-      function: {pre: [{name: "test middleware 2"}], post: []}
-      query   : {
-        pre : [{name: "test middleware 1"}]
-        post: [{name: "test middleware 2"}]
-      }
-      task    : {
-        pre : [{name: "test middleware 2"}]
-        post: [{name: "test middleware 1"}]
-      }
-      tool    : {pre: [], post: [{name: "test middleware 2"}]}
-    }
-  
-    history = {
-      function  : false
-      query     : 100
-      task      : 100
-      tool      : 100
-      trigger   : false
-      middleware: false
-    }
-  }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

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

package/parser/clauses/authClause.spec.js

@@ -1,39 +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.authClause();
-  return parser;
-}
-
-describe("authClause", () => {
-  it("authClause accepts a true value", () => {
-    const parser = parse("auth = true");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("authClause accepts a true value", () => {
-    const parser = parse("auth = false");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("authClause rejects anything else", () => {
-    const parser = parse("auth = something");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("authClause rejects digit", () => {
-    const parser = parse("auth = 123");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("authClause can be compact", () => {
-    const parser = parse("auth=true");
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/clauses/cacheClause.spec.js

@@ -1,103 +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.cacheClause();
-  return parser;
-}
-
-describe("cacheClause", () => {
-  it("cacheClause defines the cache", () => {
-    const parser = parse(`cache = {
-      ttl       : 3600
-      input     : true
-      auth      : true
-      datasource: true
-      ip        : false
-      headers   : ["foo=bar"]
-      env       : ["some_var"]
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("cacheClause headers and env are optionals", () => {
-    const parser = parse(`cache = {
-      ttl       : 3600
-      input     : true
-      auth      : true
-      datasource: true
-      ip        : false
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("cacheClause ttl should be int", () => {
-    const parser = parse(`cache = {
-      ttl       : "foo"
-      input     : true
-      auth      : true
-      datasource: true
-      ip        : false
-      headers   : ["foo=bar"]
-      env       : ["some_var"]
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("cacheClause input should be boolean", () => {
-    const parser = parse(`cache = {
-      ttl       : 3600
-      input     : "foo"
-      auth      : true
-      datasource: true
-      ip        : false
-      headers   : ["foo=bar"]
-      env       : ["some_var"]
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("cacheClause auth should be boolean", () => {
-    const parser = parse(`cache = {
-      ttl       : 3600
-      input     : true
-      auth      : "foo"
-      datasource: true
-      ip        : false
-      headers   : ["foo=bar"]
-      env       : ["some_var"]
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("cacheClause datasource should be boolean", () => {
-    const parser = parse(`cache = {
-      ttl       : 3600
-      input     : true
-      auth      : true
-      datasource: "foo"
-      ip        : false
-      headers   : ["foo=bar"]
-      env       : ["some_var"]
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("cacheClause ip should be boolean", () => {
-    const parser = parse(`cache = {
-      ttl       : 3600
-      input     : true
-      auth      : true
-      datasource: true
-      ip        : "foo"
-      headers   : ["foo=bar"]
-      env       : ["some_var"]
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

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