@xano/xanoscript-language-server 11.0.3

package/parser/generic/functionAttrReq.spec.js

@@ -0,0 +1,353 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { Identifier } from "../../lexer/tokens.js";
+import { parser } from "../test_parser.js";
+
+export function parserExtension() {
+  // this rule requires a foo field to be defined
+  this.functionAttrReq_test_required = this.RULE(
+    "functionAttrReq_test_required",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, { ARGS: [name, ["foo"]] });
+    }
+  );
+
+  // this rule has no required fields and two optional fields
+  this.functionAttrReq_test_optionals = this.RULE(
+    "functionAttrReq_test_optionals",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, { ARGS: [name, [], ["foo", "bar"]] });
+    }
+  );
+
+  // this rule has one required and one optional field
+  this.functionAttrReq_test_optional_and_required = this.RULE(
+    "functionAttrReq_test_optional_and_required",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, ["required"], ["option"]],
+      });
+    }
+  );
+
+  this.functionAttrReq_test_allow_disabled_keys = this.RULE(
+    "functionAttrReq_test_allow_disabled_keys",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, ["value", "other"], [], { allowDisabledKeys: true }],
+      });
+    }
+  );
+
+  // this rule allows duplicates for the "arg" field
+  this.functionAttrReq_test_allow_duplicates = this.RULE(
+    "functionAttrReq_test_allow_duplicates",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, [], ["arg"], { allowDuplicates: ["arg"] }],
+      });
+    }
+  );
+
+  // this rule allows an objectf for the "data" field
+  this.functionAttrReq_test_allow_object = this.RULE(
+    "functionAttrReq_test_allow_object",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, [], ["data"], { allowObject: ["data"] }],
+      });
+    }
+  );
+
+  // this rule allows an objectf for the "data" field
+  this.functionAttrReq_test_enforce_object = this.RULE(
+    "functionAttrReq_test_enforce_object",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, [], ["data"], { enforceObject: ["data"] }],
+      });
+    }
+  );
+
+  // this rule allows an objectf for the "data" field
+  this.functionAttrReq_test_allow_array = this.RULE(
+    "functionAttrReq_test_allow_array",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, [], ["data"], { allowArray: ["data"] }],
+      });
+    }
+  );
+
+  // this rule allows an objectf for the "data" field
+  this.functionAttrReq_test_allow_array_object = this.RULE(
+    "functionAttrReq_test_allow_array_object",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [
+          name,
+          [],
+          ["obj", "arr"],
+          { allowArray: ["arr"], allowObject: ["obj"] },
+        ],
+      });
+    }
+  );
+
+  this.functionAttrReq_test_mocks = this.RULE(
+    "functionAttrReq_test_mocks",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, [], ["mock", "value"]],
+      });
+    }
+  );
+
+  this.functionAttrReq_test_mocks_with_required_arg = this.RULE(
+    "functionAttrReq_test_mocks_with_required_arg",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, ["value", "mock"], []],
+      });
+    }
+  );
+
+  this.functionAttrReq_test_mock_not_allowed = this.RULE(
+    "functionAttrReq_test_mock_not_allowed",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.functionAttrReq, {
+        ARGS: [name, ["value"], []],
+      });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("functionAttrReq", () => {
+  it("functionAttrReq matched requirements", () => {
+    parse(`something { 
+      foo = "bar" 
+    }`).functionAttrReq_test_required();
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq accept another variable reference", () => {
+    parse(`something { 
+      foo = $response.foo.baz 
+    }`).functionAttrReq_test_required();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq can be on a single line when there is only one attribute", () => {
+    parse(`something { foo = "bar" }`).functionAttrReq_test_required();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq discover missing requirements", () => {
+    parse(`something { 
+      foot = "bar" 
+    }`).functionAttrReq_test_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq discover optional requirements", () => {
+    // should allow one optional requirement
+    parse(`something { 
+      foo = "bar" 
+    }`).functionAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+
+    // should allow one optional requirement
+    parse(`something { 
+      bar = "foo" 
+    }`).functionAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+
+    // should allow all optional requirements
+    parse(`something { 
+      bar = "foo" 
+      foo = "bar" 
+    }`).functionAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+
+    // should allow no optional requirements defined
+    parse(`something { 
+    }`).functionAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq allows object fields", () => {
+    parse(`something { 
+      data = { foo: "bar" }
+    }`).functionAttrReq_test_allow_object();
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq allows array fields", () => {
+    parse(`something { 
+      data = [1,2, 3]
+    }`).functionAttrReq_test_allow_array();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq allows array fields", () => {
+    parse(`something { 
+      arr = [1,2, 3]
+      obj = { foo: "bar", bar: "foo" }
+    }`).functionAttrReq_test_allow_array_object();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq allows disabled keys", () => {
+    parse(`something { 
+      value = {
+        !i_am_disabled: "bar" 
+        i_am_enabled: "foo"
+      }
+      other = {
+        i_am_enabled: "foo"
+      }
+    }`).functionAttrReq_test_allow_disabled_keys();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq allows specific duplicates", () => {
+    // foo is defined twice
+    parse(`something { 
+      arg = "fizz" 
+      arg = "buzz" 
+    }`).functionAttrReq_test_allow_duplicates();
+
+    expect(parser.errors).to.be.empty;
+
+    // foo is defined twice
+    parse(`something { 
+      arg = "fizz" 
+      arg = "buzz" 
+      foo = "bar"
+      foo = "baz"
+    }`).functionAttrReq_test_allow_duplicates();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq detects duplicates", () => {
+    // foo is defined twice
+    parse(`something { 
+      foo = "fizz" 
+      foo = "buzz" 
+    }`).functionAttrReq_test_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq enforces optional requirements", () => {
+    // foot is not an optional requirement
+    parse(`something { 
+      foot = "bar" 
+    }`).functionAttrReq_test_optionals();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq enforces optional and required fields", () => {
+    // all optional and required fields are present
+    parse(`something {
+      option = "bar"
+      required = "bar"
+    }`).functionAttrReq_test_optional_and_required();
+    expect(parser.errors).to.be.empty;
+
+    // optional field is missing (all good)
+    parse(`something {
+      required = "bar"
+    }`).functionAttrReq_test_optional_and_required();
+
+    expect(parser.errors).to.be.empty;
+
+    // required field is missing (not good)
+    parse(`something { 
+      option = "bar" 
+    }`).functionAttrReq_test_optional_and_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq enforces mock attributes as optional", () => {
+    parse(`something { 
+      mock = {
+        "should add numbers": 5
+      }
+    }`).functionAttrReq_test_mocks();
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("functionAttrReq enforces mock attributes as required", () => {
+    parse(`something { 
+      value = 5
+    }`).functionAttrReq_test_mocks_with_required_arg();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq enforces mock attributes as not allowed", () => {
+    parse(`something { 
+      mock "should add numbers" {
+        value = 5
+      }
+    }`).functionAttrReq_test_mock_not_allowed();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq prevents multiple mock attributes with duplicate names", () => {
+    parse(`something { 
+      mock "should add numbers" {
+        value = 5
+      }
+      mock "should add numbers" {
+        value = 3
+      }
+    }`).functionAttrReq_test_mocks();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("functionAttrReq allows multiple mock attributes with different names", () => {
+    parse(`something { 
+      mock = {
+        "should add numbers": 5
+        "should subtract numbers": 3
+      }
+    }`).functionAttrReq_test_mocks();
+
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/longFormVariable.js

@@ -0,0 +1,46 @@
+import { LSquare, RSquare } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+import { LongFormVariable } from "../../lexer/variables.js";
+
+/**
+ * matches the long form variable definition like
+ * $var.x
+ * $var.x.y.z
+ * $var.x[1].y
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function longFormVariable($) {
+  return () => {
+    $.CONSUME(LongFormVariable);
+    $.OR([
+      {
+        ALT: () => {
+          $.CONSUME(DotToken);
+          $.OR1([
+            {
+              ALT: () => $.CONSUME(Identifier),
+            },
+            {
+              ALT: () => {
+                $.CONSUME(LSquare);
+                $.CONSUME(StringLiteral);
+                $.CONSUME(RSquare);
+              },
+            },
+          ]);
+        },
+      },
+      {
+        ALT: () => {
+          $.CONSUME2(LSquare);
+          $.CONSUME2(StringLiteral);
+          $.CONSUME2(RSquare);
+        },
+      },
+    ]);
+    $.SUBRULE($.chainedIdentifier);
+  };
+}

package/parser/generic/longFormVariable.spec.js

@@ -0,0 +1,25 @@
+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.longFormVariable();
+  return parser;
+}
+
+describe("longFormVariable", () => {
+  it("longFormVariable accepts a property", () => {
+    const parser = parse(`$var.property`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("longFormVariable accepts a hash as a property", () => {
+    let parser = parse(`$var.["property"]`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`$var["property"]`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/minimalFnBody.js

@@ -0,0 +1,24 @@
+import { LCurly, RCurly } from "../../lexer/control.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * To be used when the body of a function is optional and can only
+ * be disabled and/or have a description.
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function minimalFnBody($) {
+  return () => {
+    $.sectionStack.push("minimalFnBody");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.OR2([
+        { ALT: () => $.SUBRULE($.descriptionFieldAttribute) },
+        { ALT: () => $.SUBRULE($.disabledFieldAttribute) },
+      ]);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.sectionStack.pop();
+  };
+}

package/parser/generic/minimalFnBody.spec.js

@@ -0,0 +1,47 @@
+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.minimalFnBody();
+  return parser;
+}
+
+describe("minimalFnBody", () => {
+  it("minimalFnBody does not accept a value", () => {
+    const parser = parse(`{
+      value = "text"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("minimalFnBody accepts a description", () => {
+    const parser = parse(`{
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("minimalFnBody can be disabled", () => {
+    const parser = parse(`{
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("minimalFnBody can be disabled and have a description", () => {
+    const parser = parse(`{
+      disabled = true
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("minimalFnBody does not requires a description or disable statement", () => {
+    const parser = parse(`{
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/mockAttribute.js

@@ -0,0 +1,21 @@
+import { EqualToken } from "../../lexer/control.js";
+import { MockToken, NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * @deprecated - use functionAttrReq instead
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function mockAttribute($) {
+  return () => {
+    $.sectionStack.push("mockAttribute");
+
+    const name = $.CONSUME(MockToken); // "mock"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.schemaParseObjectFn, {
+      ARGS: [name, { "![string]": "[expression]" }],
+    });
+    $.MANY(() => $.CONSUME(NewlineToken));
+
+    $.sectionStack.pop();
+  };
+}

package/parser/generic/mockAttribute.spec.js

@@ -0,0 +1,57 @@
+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.mockAttribute();
+  return parser;
+}
+
+describe("mock", () => {
+  it("mock accepts name and payload", () => {
+    const parser = parse(`mock = {
+      "should add numbers": 5
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("mock requires an object", () => {
+    const parser = parse(`mock = 5`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("mock name doesn't need quotes", () => {
+    const parser = parse(`mock = {
+      foo: 5
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("mock allows single line", () => {
+    const parser = parse(`mock = { "should add numbers": 5 }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("mock allows an expression as a value", () => {
+    const parser = parse(`mock = {
+      "should add numbers": 5 + 10
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("mock allows a filtered value", () => {
+    const parser = parse(`mock = {
+      "should add numbers": 5|add:10
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("mock allows an object as a value", () => {
+    const parser = parse(`mock = {
+      "should add numbers": { "foo": 5, "bar": 10 }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/multilineFilterFn.js

@@ -0,0 +1,27 @@
+import { PipeToken } from "../../lexer/control.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * Represents a multiline filter function in XanoScript
+ *
+ * Handles expression filters and query search filters
+ * e.g. |filterName:arg1:arg2 or |!filterName:arg1:arg2 (disabled)
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function multilineFilterFn($) {
+  return (options = {}) => {
+    $.SUBRULE($.filterFn, { ARGS: [options] });
+    $.MANY({
+      // This is a tricky one, we allow a new line breaking an expression but only
+      // if the following line is a filter (starts with a pipe)
+      // We use LookAhead to peek at the next tokens without consuming them
+      // to decide if we should close or keep the gate open
+      GATE: () =>
+        $.LA(1).tokenType === PipeToken ||
+        ($.LA(1).tokenType === NewlineToken && $.LA(2).tokenType === PipeToken),
+      DEF: () => {
+        $.SUBRULE1($.filterFn, { ARGS: [options] });
+      },
+    });
+  };
+}

package/parser/generic/multilineFilterFn.spec.js

@@ -0,0 +1,51 @@
+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.multilineFilterFn();
+  return parser;
+}
+
+function parseQuery(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.multilineFilterFn({ allowQueryExpression: true });
+  return parser;
+}
+
+describe("multilineFilterFn", () => {
+  it("multilineFilterFn accept valid single line filter", () => {
+    const parser = parse(`|add:2`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("multilineFilterFn accept valid multiline filter", () => {
+    const parser = parse(`|add:2
+      |divide:1`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("multilineFilterFn rejected non-existing filter", () => {
+    const parser = parse(`|add:2
+      |divider:1`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("multilineFilterFn accept valid query filter with allowQueryExpression", () => {
+    const parser = parseQuery(`|between:18:65
+      |round`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("multilineFilterFn reject invalid query filter with allowQueryExpression", () => {
+    const parser = parseQuery(`|sub:10
+      |in:[1,2,3]`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/numberValue.js

@@ -0,0 +1,27 @@
+import { FloatLiteral, IntegerLiteral } from "../../lexer/literal.js";
+
+/**
+ * A number value can be either an integer or a float.
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function numberValue($) {
+  return () => {
+    $.OR(
+      [
+        {
+          ALT: () => {
+            $.CONSUME(IntegerLiteral, { ERR_MSG: "Integer literal expected" });
+          },
+        },
+        {
+          ALT: () => {
+            $.CONSUME(FloatLiteral, { ERR_MSG: "Float literal expected" });
+          },
+        },
+      ],
+      {
+        ERR_MSG: "Number literal expected",
+      }
+    );
+  };
+}