@xano/xanoscript-language-server 11.0.3

package/parser/functions/controls/groupFn.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.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.js

@@ -0,0 +1,40 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import { PreconditionToken } from "../../../lexer/util.js";
+
+/**
+ * precondition {
+ *   error_type = "standard"
+ *   error = "Something went wrong"
+ * } as x6
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function preconditionFn($) {
+  return () => {
+    $.sectionStack.push("preconditionFn");
+    const tokenFn = $.CONSUME(PreconditionToken); // "precondition"
+    $.CONSUME(LParent);
+    $.SUBRULE($.expressionFn);
+    $.CONSUME(RParent);
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        tokenFn,
+        {
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "payload?": "[expression]",
+          "error?": "[expression]",
+          "error_type?": [
+            "standard",
+            "notfound",
+            "accessdenied",
+            "toomanyrequests",
+            "unauthorized",
+            "badrequest",
+            "inputerror",
+          ],
+        },
+      ],
+    });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,97 @@
+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("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/register.js

@@ -0,0 +1,45 @@
+import { awaitFn } from "./awaitFn.js";
+import { conditionalElifFn } from "./conditionalElifFn.js";
+import { conditionalElseFn } from "./conditionalElseFn.js";
+import { conditionalFn } from "./conditionalFn.js";
+import { conditionalIfFn } from "./conditionalIfFn.js";
+import { forEachFn } from "./forEachFn.js";
+import { forFn } from "./forFn.js";
+import { functionCallFn } from "./functionCallFn.js";
+import { functionRunFn } from "./functionRunFn.js";
+import { groupFn } from "./groupFn.js";
+import { preconditionFn } from "./preconditionFn.js";
+import { returnFn } from "./returnFn.js";
+import { switchCaseFn } from "./switchCaseFn.js";
+import { switchDefaultFn } from "./switchDefaultFn.js";
+import { switchFn } from "./switchFn.js";
+import { taskCallFn } from "./taskCallFn.js";
+import { throwFn } from "./throwFn.js";
+import { tryCatchFn } from "./tryCatchFn.js";
+import { whileFn } from "./whileFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.awaitFn = $.RULE("awaitFn", awaitFn($));
+  $.conditionalElifFn = $.RULE("conditionalElifFn", conditionalElifFn($));
+  $.conditionalElseFn = $.RULE("conditionalElseFn", conditionalElseFn($));
+  $.conditionalFn = $.RULE("conditionalFn", conditionalFn($));
+  $.conditionalIfFn = $.RULE("conditionalIfFn", conditionalIfFn($));
+  $.forEachFn = $.RULE("forEachFn", forEachFn($));
+  $.forFn = $.RULE("forFn", forFn($));
+  $.functionRunFn = $.RULE("functionRunFn", functionRunFn($));
+  $.functionCallFn = $.RULE("functionCallFn", functionCallFn($));
+  $.taskCallFn = $.RULE("taskCallFn", taskCallFn($));
+  $.groupFn = $.RULE("groupFn", groupFn($));
+  $.preconditionFn = $.RULE("preconditionFn", preconditionFn($));
+  $.returnFn = $.RULE("returnFn", returnFn($));
+  $.switchCaseFn = $.RULE("switchCaseFn", switchCaseFn($));
+  $.switchDefaultFn = $.RULE("switchDefaultFn", switchDefaultFn($));
+  $.switchFn = $.RULE("switchFn", switchFn($));
+  $.throwFn = $.RULE("throwFn", throwFn($));
+  $.tryCatchFn = $.RULE("tryCatchFn", tryCatchFn($));
+  $.whileFn = $.RULE("whileFn", whileFn($));
+};

package/parser/functions/controls/returnFn.js

@@ -0,0 +1,21 @@
+import { ReturnToken } from "../../../lexer/control.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function returnFn($) {
+  const requiredAttrs = ["value"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("return");
+    const tokenFn = $.CONSUME(ReturnToken); // "return"
+    // value is a required field
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [tokenFn, requiredAttrs, optionalAttrs],
+    });
+
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,44 @@
+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/switchCaseFn.js

@@ -0,0 +1,22 @@
+import {
+  BreakToken,
+  CaseToken,
+  LParent,
+  RParent,
+} from "../../../lexer/control.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function switchCaseFn($) {
+  return () => {
+    $.sectionStack.push("switchCaseFn");
+    $.CONSUME(CaseToken); // "case"
+    $.CONSUME(LParent); // "("
+    $.SUBRULE($.expressionFn);
+    $.CONSUME(RParent); // ")"
+    $.OPTION(() => $.SUBRULE($.nakedStackFn));
+    $.OPTION1(() => $.CONSUME(BreakToken)); // "break"
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/controls/switchDefaultFn.js

@@ -0,0 +1,13 @@
+import { DefaultToken } from "../../../lexer/control.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function switchDefaultFn($) {
+  return () => {
+    $.sectionStack.push("switchDefaultFn");
+    $.CONSUME(DefaultToken); // "default"
+    $.SUBRULE($.nakedStackFn);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/controls/switchFn.js

@@ -0,0 +1,50 @@
+import {
+  LCurly,
+  LParent,
+  RCurly,
+  RParent,
+  SwitchToken,
+} from "../../../lexer/control.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function switchFn($) {
+  return () => {
+    $.sectionStack.push("switchFn");
+    $.CONSUME(SwitchToken); // "switch"
+    $.CONSUME(LParent); // "("
+    $.SUBRULE($.expressionFn);
+    $.CONSUME(RParent); // ")"
+    $.OPTION(() => {
+      $.CONSUME(LCurly); // "{"
+      $.MANY(() => {
+        $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+        $.OR([
+          { ALT: () => $.SUBRULE($.descriptionFieldAttribute) },
+          { ALT: () => $.SUBRULE($.disabledFieldAttribute) },
+          {
+            ALT: () => {
+              $.MANY1(() => {
+                $.MANY3(() => $.CONSUME3(NewlineToken));
+                $.SUBRULE($.switchCaseFn);
+              });
+            },
+          },
+        ]);
+      });
+
+      // finally, the optional default case
+      $.OPTION1(() => {
+        $.MANY4(() => $.CONSUME4(NewlineToken));
+        $.SUBRULE($.switchDefaultFn);
+      });
+
+      $.MANY2(() => $.CONSUME1(NewlineToken));
+      $.CONSUME(RCurly); // "}"
+    });
+
+    $.sectionStack.pop();
+  };
+}

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

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

package/parser/functions/controls/taskCallFn.js

@@ -0,0 +1,31 @@
+import { StringLiteral } from "../../../lexer/literal.js";
+import { CallToken, TaskToken } from "../../../lexer/task.js";
+import { DotToken, Identifier } from "../../../lexer/tokens.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function taskCallFn($) {
+  const requiredAttrs = [];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("taskCallFn");
+    $.CONSUME(TaskToken); // "task"
+    $.CONSUME(DotToken); // "."
+    const fnToken = $.CONSUME(CallToken); // "call"
+
+    $.OR([
+      { ALT: () => $.CONSUME(Identifier) }, // user
+      { ALT: () => $.CONSUME1(StringLiteral) }, // "user/ auth"
+    ]);
+
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/controls/throwFn.js

@@ -0,0 +1,21 @@
+import { ThrowToken } from "../../../lexer/control.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function throwFn($) {
+  const requiredAttrs = ["value", "name"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("throw");
+    const tokenFn = $.CONSUME(ThrowToken); // "throw"
+    // value is a required field
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [tokenFn, requiredAttrs, optionalAttrs],
+    });
+
+    $.sectionStack.pop();
+  };
+}

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

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

@@ -0,0 +1,67 @@
+import {
+  CatchToken,
+  FinallyToken,
+  LCurly,
+  RCurly,
+  TryCatchToken,
+  TryToken,
+} from "../../../lexer/control.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function tryCatchFn($) {
+  return () => {
+    let hasTry = false;
+    let hasCatch = false;
+
+    $.sectionStack.push("tryCatchFn");
+    $.CONSUME(TryCatchToken); // "try_catch"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.OR([
+        { ALT: () => $.SUBRULE($.descriptionFieldAttribute) },
+        { ALT: () => $.SUBRULE($.disabledFieldAttribute) },
+        {
+          ALT: () => {
+            hasTry = true;
+            $.CONSUME(TryToken);
+            $.OPTION(() => $.SUBRULE($.nakedStackFn));
+          },
+        },
+        {
+          ALT: () => {
+            hasCatch = true;
+            $.CONSUME(CatchToken);
+            $.sectionStack.push("catchFn");
+            $.OPTION1(() => $.SUBRULE1($.nakedStackFn));
+            $.sectionStack.pop();
+          },
+        },
+        {
+          ALT: () => {
+            $.CONSUME(FinallyToken);
+            $.OPTION2(() => $.SUBRULE2($.nakedStackFn));
+          },
+        },
+      ]);
+    });
+
+    if (!hasTry) {
+      $.CONSUME(TryToken);
+      $.SUBRULE($.nakedStackFn);
+    }
+
+    if (!hasCatch) {
+      $.CONSUME(CatchToken);
+      $.SUBRULE($.nakedStackFn);
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+
+    $.sectionStack.pop();
+  };
+}