@xano/xanoscript-language-server 11.0.3

package/parser/functions/expect/workflowExpectWithArgumentsFn.spec.js

@@ -0,0 +1,301 @@
+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.workflowExpectWithArgumentsFn();
+  return parser;
+}
+
+describe("workflowExpectWithArgumentsFn", () => {
+  // to_equal
+  it("workflowExpectWithArgumentsFn to_equal accepts a $var.x variable", () => {
+    const parser = parse(`to_equal ($var.x) {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn accepts an $input variable", () => {
+    const parser = parse(`to_equal ($input.x) {
+      value = 12
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn accepts a filtered variable", () => {
+    // foo is not in quotes
+    let parser = parse(`to_equal ($x|get:foo:"bar") {
+      value = 12
+    }`);
+    expect(parser.errors).to.not.be.empty;
+
+    // all good, foo is in quotes
+    parser = parse(`to_equal ($x|get:"foo":"bar") {
+      value = 12
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    // foo is not in quotes but is in an expression markers
+    parser = parse(`to_equal (\`$x|get:foo:"bar"\`) {
+      value = 12
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn accepts a description", () => {
+    const parser = parse(`to_equal ($foo) {
+      value = 12
+      description = "This is a description"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn accepts a disabled attribute", () => {
+    const parser = parse(`to_equal ($foo) {
+      value = 12
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_equal accepts a filter on $variable argument", () => {
+    let parser = parse(`to_equal ($variable|get:"foo":"bar") {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal (\`variable|get:"foo":"bar"\`) {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`to_equal (variable|get:"foo":bar) {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_equal accepts a $variable with a subpath", () => {
+    const parser = parse(`to_equal ($variable.x) {
+      value = "foo"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_equal rejects a missing value", () => {
+    let parser = parse(`to_equal ($variable) {
+    };`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`to_equal ($variable)`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_equal rejects a missing argument", () => {
+    const parser = parse(`to_equal {
+      value = 10
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  // to_start_with
+  it("workflowExpectWithArgumentsFn to_start_with accepts a $variable", () => {
+    const parser = parse(`to_start_with ($variable) {
+      value = "bar"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_start_with rejects a missing argument", () => {
+    const parser = parse(`to_start_with {
+      value = "bar"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_start_with rejects a missing value", () => {
+    const parser = parse(`to_start_with ($variable) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_start_with accepts subattribute from variable", () => {
+    const parser = parse(`to_start_with ($variable.x) {
+      value = "bar"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_end_with
+  it("workflowExpectWithArgumentsFn to_end_with accepts a $variable variable", () => {
+    const parser = parse(`to_end_with ($variable) {
+      value = "baz"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_end_with rejects a missing value", () => {
+    const parser = parse(`to_end_with ($variable) {
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_end_with rejects a missing argument", () => {
+    const parser = parse(`to_end_with {
+      value = "baz"
+    };`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_end_with does accept subattribute from variable", () => {
+    const parser = parse(`to_end_with ($variable.x) {
+      value = "baz"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_be_greater_than
+  it("workflowExpectWithArgumentsFn to_be_greater_than accepts a $variable variable", () => {
+    const parser = parse(`to_be_greater_than ($variable) {
+      value = 10
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_be_greater_than rejects a missing argument", () => {
+    const parser = parse(`to_be_greater_than {
+      value = 22 + 12
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_be_greater_than rejects a missing value", () => {
+    const parser = parse(`to_be_greater_than ($variable) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_be_greater_than does accept subattribute from variable", () => {
+    const parser = parse(`to_be_greater_than ($variable.x) {
+      value = $variable.y + 10
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_be_less_than
+  it("workflowExpectWithArgumentsFn to_be_less_than accepts a $variable variable", () => {
+    const parser = parse(`to_be_less_than ($variable) {
+      value = 10
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_be_less_than rejects a missing value", () => {
+    const parser = parse(`to_be_less_than ($variable) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_be_less_than rejects a missing argument", () => {
+    const parser = parse(`to_be_less_than {
+      value = 10
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_be_less_than does accept subattribute from variable", () => {
+    const parser = parse(`to_be_less_than ($variable.x) {
+      value = $variable.y - 55
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_match
+  it("workflowExpectWithArgumentsFn to_match accepts a $variable variable", () => {
+    const parser = parse(`to_match ($variable) {
+      value = "pattern"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_match rejects a missing argument", () => {
+    const parser = parse(`to_match {
+      value = $variable
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_match rejects a missing value", () => {
+    const parser = parse(`to_match ($variable) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_match does accept subattribute from variable", () => {
+    const parser = parse(`to_match ($variable.x) {
+      value = "pattern"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_not_equal
+  it("workflowExpectWithArgumentsFn to_not_equal accepts a $variable variable", () => {
+    const parser = parse(`to_not_equal ($variable) {
+      value = "notfoo"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_not_equal rejects a missing value", () => {
+    const parser = parse(`to_not_equal ($variable) {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_not_equal rejects a missing argument", () => {
+    const parser = parse(`to_not_equal {
+      value = 66
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_not_equal does accept subattribute from variable", () => {
+    const parser = parse(`to_not_equal ($variable.x) {
+      value = $variable.y
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // to_contain
+  it("workflowExpectWithArgumentsFn to_contain accepts a $variable variable", () => {
+    const parser = parse(`to_contain ($variable) {
+      value = "needle"
+    };`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_contain rejects a missing argument", () => {
+    const parser = parse(`to_contain {
+      value = $variable.x
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_contain rejects a missing value", () => {
+    const parser = parse(`to_contain ($variable){
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithArgumentsFn to_contain does accept subattribute from variable", () => {
+    const parser = parse(`to_contain ($haystack){
+      value = "needle"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/expect/workflowExpectWithoutArgumentsFn.js

@@ -0,0 +1,39 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import {
+  ToBeDefinedToken,
+  ToBeEmptyToken,
+  ToBeFalseToken,
+  ToBeInTheFutureToken,
+  ToBeInThePastToken,
+  ToBeNullToken,
+  ToBeTrueToken,
+  ToNotBeDefinedToken,
+  ToNotBeNullToken,
+} from "../../../lexer/expect.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function workflowExpectWithoutArgumentsFn($) {
+  return () => {
+    $.sectionStack.push("workflowExpectWithoutArgumentsFn");
+    const fnToken = $.OR([
+      { ALT: () => $.CONSUME(ToBeTrueToken) }, // "to_be_true"
+      { ALT: () => $.CONSUME(ToBeFalseToken) }, // "to_be_false"
+      { ALT: () => $.CONSUME(ToBeInThePastToken) }, // "to_be_in_the_past"
+      { ALT: () => $.CONSUME(ToBeInTheFutureToken) }, // "to_be_in_the_future"
+      { ALT: () => $.CONSUME(ToBeDefinedToken) }, // "to_be_defined"
+      { ALT: () => $.CONSUME(ToNotBeDefinedToken) }, // "to_not_be_defined"
+      { ALT: () => $.CONSUME(ToBeNullToken) }, // "to_be_null"
+      { ALT: () => $.CONSUME(ToNotBeNullToken) }, // "to_not_be_null"
+      { ALT: () => $.CONSUME(ToBeEmptyToken) }, // "to_be_empty"
+    ]);
+    $.CONSUME(LParent); // "("
+    $.SUBRULE($.expressionFn); // "$foo|get:bar:null"
+    $.CONSUME(RParent); // ")"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, [], ["description", "disabled"]],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/workflowExpectWithoutArgumentsFn.spec.js

@@ -0,0 +1,87 @@
+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.workflowExpectWithoutArgumentsFn();
+  return parser;
+}
+
+describe("workflowExpectWithoutArgumentsFn", () => {
+  it("workflowExpectWithoutArgumentsFn has the expect to_be_true", () => {
+    const parser = parse(`to_be_true ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn accepts an $input variable", () => {
+    const parser = parse(`to_be_true ($input.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn accepts a filter on var argument", () => {
+    let parser = parse(`to_be_true ($x|get:"foo":"bar")`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse('to_be_true (`$x|get:foo:"bar"`)');
+    expect(parser.errors).to.be.empty;
+
+    parser = parse("to_be_true (`$x|get:foo:bar`)");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse('to_be_true ($x|get:foo:"bar")');
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn accepts a description", () => {
+    const parser = parse(`to_be_false ($x) {
+      description = "This is a description"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn can be disabled", () => {
+    const parser = parse(`to_be_false ($x) {
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_be_in_the_past", () => {
+    const parser = parse(`to_be_in_the_past ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_be_in_the_future", () => {
+    const parser = parse(`to_be_in_the_future ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_be_defined", () => {
+    const parser = parse(`to_be_defined ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_not_be_defined", () => {
+    const parser = parse(`to_not_be_defined ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_be_null", () => {
+    const parser = parse(`to_be_null ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_not_be_null", () => {
+    const parser = parse(`to_not_be_null ($response)`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("workflowExpectWithoutArgumentsFn has the expect to_be_empty", () => {
+    const parser = parse(`to_be_empty ($var.x)`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/math/allMathFn.js

@@ -0,0 +1,64 @@
+import { LCurly, RCurly } from "../../../lexer/control.js";
+import {
+  AddToken,
+  AndToken,
+  BitwiseToken,
+  DivToken,
+  ModToken,
+  MulToken,
+  OrToken,
+  SubToken,
+  XorToken,
+} from "../../../lexer/math.js";
+import { DotToken as DotToken, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function allMathFn($) {
+  return () => {
+    let hasValue = false;
+    $.sectionStack.push("allMathFn");
+    $.OR([
+      { ALT: () => $.CONSUME(AddToken) }, // math.add
+      { ALT: () => $.CONSUME(DivToken) }, // math.div
+      { ALT: () => $.CONSUME(ModToken) }, // math.mod
+      { ALT: () => $.CONSUME(MulToken) }, // math.mul
+      { ALT: () => $.CONSUME(SubToken) }, // math.sub
+      {
+        ALT: () => {
+          $.CONSUME(BitwiseToken);
+          $.CONSUME(DotToken);
+          $.OR1([
+            { ALT: () => $.CONSUME(AndToken) }, // math.bitwise.and
+            { ALT: () => $.CONSUME(OrToken) }, // math.bitwise.or
+            { ALT: () => $.CONSUME(XorToken) }, // math.bitwise.xor
+          ]);
+        },
+      },
+    ]);
+    $.SUBRULE($.assignableVariableProperty);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.OR2([
+        {
+          ALT: () => {
+            hasValue = true;
+            $.SUBRULE($.valueFieldAttribute);
+          },
+        },
+        { ALT: () => $.SUBRULE($.descriptionFieldAttribute) },
+        { ALT: () => $.SUBRULE($.disabledFieldAttribute) },
+      ]);
+    });
+
+    if (!hasValue) {
+      $.SUBRULE($.valueFieldAttribute);
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/math/allMathFn.spec.js

@@ -0,0 +1,100 @@
+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.allMathFn();
+  return parser;
+}
+
+describe("allMathFn", () => {
+  it("allMathFn accepts a value", () => {
+    const parser = parse(`add $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn requires a value", () => {
+    const parser = parse(`add $x1 {
+      description = "foo"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("allMathFn accepts a description", () => {
+    const parser = parse(`add $x1 {
+      value = $x1
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can be disabled", () => {
+    const parser = parse(`add $x1 {
+      value = $x1
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn accepts a long form variable", () => {
+    const parser = parse(`add $var.x1 {
+      value = $x1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn accepts an attribute for assignment", () => {
+    const parser = parse(`add $x1.bar {
+      value = $x1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can sub", () => {
+    const parser = parse(`sub $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can mul", () => {
+    const parser = parse(`mul $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can div", () => {
+    const parser = parse(`div $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can bitwise.xor", () => {
+    const parser = parse(`bitwise.xor $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can bitwise.and", () => {
+    const parser = parse(`bitwise.and $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allMathFn can bitwise.or", () => {
+    const parser = parse(`bitwise.or $x1 {
+      value = 1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/math/register.js

@@ -0,0 +1,9 @@
+import { allMathFn } from "./allMathFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.allMathFn = $.RULE("allMathFn", allMathFn($));
+};

package/parser/functions/mathFn.js

@@ -0,0 +1,15 @@
+import { MathToken } from "../../lexer/math.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function mathFn($) {
+  return () => {
+    $.sectionStack.push("math");
+    $.CONSUME(MathToken); // "math"
+    $.CONSUME(DotToken); // "."
+    $.SUBRULE($.allMathFn);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/middlewareCallFn.js

@@ -0,0 +1,43 @@
+import { CallToken } from "../../lexer/action.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { MiddlewareToken } from "../../lexer/middleware.js";
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function middlewareCallFn($) {
+  return () => {
+    $.sectionStack.push("middlewareCallFn");
+    $.CONSUME(MiddlewareToken); // "middleware"
+    $.CONSUME(DotToken); // "."
+    const fnToken = $.CONSUME(CallToken); // "call"
+
+    $.OR([
+      { ALT: () => $.CONSUME(Identifier) }, // user
+      { ALT: () => $.CONSUME1(StringLiteral) }, // "user auth"
+    ]);
+
+    $.OPTION(() => {
+      $.SUBRULE($.schemaParseAttributeFn, {
+        ARGS: [
+          fnToken,
+          {
+            input: {
+              vars: "[expression]",
+              type: "[expression]",
+            },
+            "mock?": { "![string]": "[expression]" },
+            "description?": "[string]",
+            "disabled?": "[boolean]",
+          },
+        ],
+      });
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}