@xano/xanoscript-language-server 11.12.2 → 12.0.0

package/parser/functions/controls/functionRunFn.spec.js

@@ -1,87 +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.functionRunFn();
-  return parser;
-}
-
-describe("functionRunFn", () => {
-  it("functionRunFn accepts data field", () => {
-    const parser = parse(`function.run add {
-      input = {a: $input.a, b: $b}
-    } as $func1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn accepts an empty payload", () => {
-    const parser = parse(`function.run add {
-      input = {}
-    } as $func1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn accepts complex expression as input", () => {
-    const parser = parse(`function.run "my_complex_function" {
-      input = {
-        Snumber     : (($SomeVar.0.var_rel/55) > 0 ? ($SomeVar.0.var_rel1/61) : 6)+(($My_Var_S2.0.elo/ 60) > 7 ? ($My_Var_S2.0.elo/62) : 9)+(($Optional_var2.0.det/63) > 4 ? ($Optional_var2.0.det /64) : 2)+(($PtSgeS_sge.0.elo/65) > 1 ? ($PtSgeS_sge.0.elo/66) : 3)
-        NumberObject: []
-      }
-    } as $Var_Round`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn accepts a string for function name", () => {
-    const parser = parse(`function.run "my/function" {
-      input = {a: $input.a, b: $b}
-    } as $func1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn can be disabled", () => {
-    const parser = parse(`function.run add {
-      input = {a: $input.a, b: $b}
-      disabled = true
-    } as $new_user`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn can call a function in a folder", () => {
-    const parser = parse(`function.run "math/add" {
-      input = {a: $input.a, b: $b}
-    } as $new_user`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn can call requires quote when calling a function in a folder", () => {
-    const parser = parse(`function.run math/add {
-      input = {a: $input.a, b: $b}
-    } as $new_user`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionRunFn rejects input that is not an object", () => {
-    const parser = parse(`function.run math/add {
-      input = $input
-    } as $new_user`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionRunFn accepts a description", () => {
-    const parser = parse(`function.run add {
-      description = "run a function"
-      input = {a: $input.a, b: $b}
-    } as $new_user`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionRunFn can be empty", () => {
-    const parser = parse(`function.run add as $user`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/controls/groupFn.spec.js

@@ -1,63 +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.groupFn();
-  return parser;
-}
-
-describe("groupFn", () => {
-  it("groupFn can have an empty body", () => {
-    const parser = parse(`group {
-      stack 
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("groupFn contains a stack", () => {
-    const parser = parse(`group {
-      stack {
-        util.sleep {
-          value = 1000
-          }
-        }  
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("groupFn accepts a description", () => {
-    const parser = parse(`group {
-      stack {
-        util.sleep {
-          value = 1000
-        }
-      }  
-      description = "foo"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("groupFn can be disabled", () => {
-    const parser = parse(`group {
-      stack {
-        util.sleep {
-          value = 1000
-        }
-      }  
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("groupFn requires a stack", () => {
-    const parser = parse(`group {
-      description = "foo"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/controls/preconditionFn.spec.js

@@ -1,107 +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.preconditionFn();
-  return parser;
-}
-
-describe("preconditionFn", () => {
-  it("preconditionFn accept an expression and error info", () => {
-    const parser = parse(`precondition ($x1 == $x2) {
-      error_type = "standard"
-      error = ""
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn accepts an negated variable as expression", () => {
-    const parser = parse(`precondition (!$x1) {
-      error_type = "standard"
-      error = ""
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("should accept a complex precondition expression", () => {
-    const parser =
-      parse(`precondition (($a_rate >= ($rate_token.x_rate * (1 - ($env.x_rate_all / 100)))) && ($a_rate <= ($rate_token.x_rate * (1 + ($env.x_rate_all / 100))))) {
-        error_type = "badrequest"
-        error = "ohoh"
-        payload = "The rate is off"
-      }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn accept an escaped string", () => {
-    const parser = parse(
-      `precondition ($escaped == '\\"hello this is chris\\\\\\' test\\"')`,
-    );
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("precondition accepts a not symbol in expression", () => {
-    const parser =
-      parse(`precondition ((($var.wallets|is_empty) && !(($input.wallet_id|is_empty) && ($input.noExist|is_empty))) == false) {
-      error = "errr"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn also accept a disabled field", () => {
-    const parser = parse(`precondition ($x1 == $x2) {
-      error_type = "standard"
-      error = ""
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn can have no arguments", () => {
-    const parser = parse(`precondition ($x1 == $x2)`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn also accept a description field", () => {
-    const parser = parse(`precondition ($x1 == $x2) {
-      error_type = "standard"
-      error = ""
-      description = "some description"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn also accept a description and a disabled field", () => {
-    const parser = parse(`precondition ($x1 == $x2) {
-      error_type = "standard"
-      error = ""
-      disabled = true
-      description = "some description"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn also accept multiple filters", () => {
-    const parser =
-      parse(`precondition (([]|push:21|push:3|push:3.5|push:-3.4|array_max) == 21) {
-      error_type = "standard"
-      error = ""
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("preconditionFn also accept combined conditionals", () => {
-    const parser =
-      parse(`precondition (($input.data|is_array) && (($input.data|count) > 0)) {
-      error_type = "inputerror"
-      error = "Invalid data input. Expected a non-empty array."
-      description = "Validate that the data input is a non-empty array."
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/controls/returnFn.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.returnFn();
-  return parser;
-}
-
-describe("returnFn", () => {
-  it("returnFn accepts a value", () => {
-    const parser = parse(`return {
-      value = "live"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("returnFn can be disabled", () => {
-    const parser = parse(`return {
-      value = "live"
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("returnFn accepts a description", () => {
-    const parser = parse(`return {
-      value = "live"
-      description = "check if a user exists"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("returnFn requires a value", () => {
-    const parser = parse(`return {
-      description = "check if a user exists"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/controls/switchFn.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) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.switchFn();
-  return parser;
-}
-
-describe("switchFn", () => {
-  it("switchFn can be an empty statement", () => {
-    const parser = parse(`switch ($input.a)`);
-    expect(parser.errors).to.be.empty;
-  });
-  it("switchFn accept a case statement", () => {
-    const parser = parse(`switch ($input.a) {
-      case (12) { 
-        var $x {
-          value = 12
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("switchFn accept a default statement", () => {
-    const parser = parse(`switch ($input.a) {
-      default {
-        var $x2 {
-          value = 12212
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("switchFn accept break statement", () => {
-    const parser = parse(`switch ($input.a) {
-      case (12) { 
-        var $x {
-          value = 12
-        }
-      } break
-      case (13) break
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("switchFn accepts a description", () => {
-    const parser = parse(`switch ($input.a) {
-      description = "foo"
-       case (12)  { 
-        var $x {
-          value = 12
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("switchFn can be disabled", () => {
-    const parser = parse(`switch ($input.a) {
-      disabled = true
-      case ($input.b) { 
-        var $x {
-          value = 12
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("switchFn does not requires a statement", () => {
-    const parser = parse(`switch ($input.a) {
-      description = "foo"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("switchFn requires ordered case, case..., default", () => {
-    const parser = parse(`switch ($input.a) {
-      case (1) { 
-        var $x {
-          value = 12
-        }
-      }
-      default {
-        var $y {
-          value = 36
-        }
-      }
-      case (12) {
-        var $y {
-          value = "alpha"
-        }
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("switchFn accepts comments on case", () => {
-    const parser = parse(`switch ("myvar") {
-          // a comment for this case
-          case (1) break
-        
-          default {
-            debug.stop {
-              value = "do something"
-            }
-          }
-        }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/controls/throwFn.spec.js

@@ -1,56 +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.throwFn();
-  return parser;
-}
-
-describe("throwFn", () => {
-  it("throwFn accepts a value", () => {
-    const parser = parse(`throw {
-      name = "throw error"
-      value = "oppsy"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("throwFn can be disabled", () => {
-    const parser = parse(`throw {
-      name = "throw error"
-      value = "oppsy"
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("throwFn accepts a description", () => {
-    const parser = parse(`throw {
-      name = "throw error"
-      value = "oppsy"
-      description = "check if a user exists"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("throwFn requires a value", () => {
-    const parser = parse(`throw {
-      name = "throw error"
-      description = "check if a user exists"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("throwFn requires a name", () => {
-    const parser = parse(`throw {
-      value = "oppsy"
-      description = "check if a user exists"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/controls/tryCatchFn.spec.js

@@ -1,193 +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.tryCatchFn();
-  return parser;
-}
-
-describe("tryCatchFn", () => {
-  it("tryCatchFn can have an empty body", () => {
-    const parser = parse(`try_catch {
-      try
-      catch
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tryCatchFn only try is required, catch and finally are optional", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).to.not.be.empty;
-  });
-
-  it("tryCatchFn try and catch can contain a stack", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    
-      catch {
-        var $x1 {
-          value = "try"
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tryCatchFn allows $error", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    
-      catch {
-        var $x1 {
-          value = {
-            name: $error.name
-            code: $error.code
-            message: $error.message
-            result: $error.result
-          }
-        }
-        var.update $x2 {
-          value = $error
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tryCatchFn rejects unknown $error attributes", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    
-      catch {
-        var $x1 {
-          value = $error.unknown
-        }
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("tryCatchFn rejects $error outside of catch block", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = $error.message
-        }
-      }
-    
-      catch {
-        var $x1 {
-          value = $error.code
-        }
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("tryCatchFn accepts a description", () => {
-    const parser = parse(`try_catch {
-      description = "try catch block"
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    
-      catch {
-        var $x1 {
-          value = "try"
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tryCatchFn can be disabled", () => {
-    const parser = parse(`try_catch {
-      disabled = true
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    
-      catch {
-        var $x1 {
-          value = "try"
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tryCatchFn accepts a finally block", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-
-      catch {
-        var $x1 {
-          value = "catch"
-        }
-      }
-
-      finally {
-        var $x1 {
-          value = "finally"
-        }
-      }              
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tryCatchFn requires a try block", () => {
-    const parser = parse(`try_catch {
-      catch {
-        var $x1 {
-          value = "try"
-        }
-      }
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("tryCatchFn warns when catch block is missing", () => {
-    const parser = parse(`try_catch {
-      try {
-        var $x1 {
-          value = "try"
-        }
-      }
-    }`);
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).to.not.be.empty;
-    expect(parser.warnings[0].message).to.include("catch");
-  });
-});