@xano/xanoscript-language-server 11.0.3

package/parser/generic/objectWithAttributes.js

@@ -0,0 +1,74 @@
+import { ExclamationToken } from "../../lexer/cast.js";
+import { ColonToken, CommaToken, LCurly, RCurly } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { Identifier, NewlineToken } from "../../lexer/tokens.js";
+import { getVarName } from "./utils.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function objectWithAttributes($) {
+  return (options = {}) => {
+    const keys = [];
+
+    const parent = $.CONSUME(LCurly); // "{"
+    $.MANY(() => $.CONSUME(NewlineToken));
+    $.MANY_SEP({
+      SEP: NewlineToken,
+      DEF: () => {
+        let hasAtLeastOneAttribute = false;
+        let has_separator = false;
+        // single line definition separated by commas
+        $.MANY1(() => {
+          // multi line, each key value pair on a new line
+          // {
+          //   key: value
+          //   key2: value2
+          // }
+
+          // if we have at least one attribute, the separator is required
+          if (hasAtLeastOneAttribute && !has_separator) {
+            $.addMissingError(
+              parent,
+              "Expected a separator between attributes"
+            );
+          }
+
+          // optionally consume as many new line present
+          // $.MANY2(() => $.CONSUME2(NewlineToken));
+          $.OPTION1({
+            GATE: () => options.allowDisabledKeys === true,
+            DEF: () => $.CONSUME(ExclamationToken),
+          });
+          const key = $.OR1([
+            { ALT: () => $.CONSUME2(Identifier) }, // my_key
+            { ALT: () => $.CONSUME2(StringLiteral) }, // "my key"
+          ]);
+
+          // prevent duplicate keys
+          const varName = getVarName(key);
+          if (keys.includes(varName)) {
+            $.addDuplicateAttributeError(key);
+          } else {
+            keys.push(varName);
+          }
+
+          $.CONSUME(ColonToken); // ":"
+          $.SUBRULE($.expressionFn, { ARGS: [key, options] }); // e.g., "A value of the field"
+
+          $.OPTION(() => {
+            $.CONSUME(CommaToken);
+            has_separator = true;
+          });
+
+          // mark that we have our first attribute in, we will require a separator
+          // to add more attributes
+          hasAtLeastOneAttribute = true;
+        });
+      },
+    });
+
+    $.MANY3(() => $.CONSUME3(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+  };
+}

package/parser/generic/objectWithAttributes.spec.js

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+export function parserExtension() {
+  // this rule has no required fields and two optional fields
+  this.objectWithAttributes_test_object_query = this.RULE(
+    "objectWithAttributes_test_test_object_with_attr_query",
+    () => {
+      this.SUBRULE(this.objectWithAttributes, {
+        ARGS: [{ allowQueryExpression: true }],
+      });
+    }
+  );
+
+  this.objectWithAttributes_basic = this.RULE(
+    "objectWithAttributes_test_object_with_attr",
+    () => {
+      this.SUBRULE(this.objectWithAttributes);
+    }
+  );
+
+  this.objectWithAttributes_disabledKeys = this.RULE(
+    "objectWithAttributes_disabledKeys",
+    () => {
+      this.SUBRULE(this.objectWithAttributes, {
+        ARGS: [{ allowDisabledKeys: true }],
+      });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+describe("objectWithAttributes", () => {
+  it("objectWithAttributes accepts an object with attributes", () => {
+    parse(`{ value: "test"}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes enforces unique keys", () => {
+    parse(`{ value: "test", value: "test2"}`).objectWithAttributes_basic();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectWithAttributes passes options to its children", () => {
+    parse(`{ value: "test", value: "test2"}`).objectWithAttributes_basic();
+    expect(parser.errors).to.not.be.empty;
+  });
+  it("objectWithAttributes accepts an object with object as a value", () => {
+    parse(`{ value: { name: "john"}}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts a boolean value", () => {
+    parse(`{ value: false}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts null value", () => {
+    parse(`{ value: null}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts multiple values", () => {
+    parse(`{ value: null, other: "test"}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes reject multiple values without a separator", () => {
+    parse(`{ value: null other: "test"}`).objectWithAttributes_basic();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectWithAttributes accepts a trailing commas", () => {
+    parse(`{ value: null, other: "test",}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes can be on a new line", () => {
+    parse(`{ 
+      value: null, other: "test",
+    }`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts an empty object", () => {
+    parse(`{ }`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts a query object", () => {
+    parse(`{ 
+      foo: $db.order.foo
+      bar: $db.book.bar|concat:"test"
+    }`).objectWithAttributes_test_object_query();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes reject non query filters object", () => {
+    parse(`{ 
+      foo: [12,3]|pop
+      bar: $db.book.bar
+    }`).objectWithAttributes_test_object_query();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectWithAttributes accepts multiple line object separated with new lines", () => {
+    parse(`{
+      value: null
+      other: "test"
+    }`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts multiple line object separated with new lines", () => {
+    parse(`{
+      value: null
+      !other: "test"
+    }`).objectWithAttributes_disabledKeys();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts combined single and multiple line object separated with commas", () => {
+    parse(`{
+      value: null, other: "test",
+      something: "test", 
+      "another value": 12
+
+
+      someone: "test", and: $var.Blah
+
+
+      foo: "bar"}`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectWithAttributes accepts an array as value ", () => {
+    parse(`{ values: [1, 2, 3] }`).objectWithAttributes_basic();
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/optionalCommentBlock.js

@@ -0,0 +1,32 @@
+import { CommentToken } from "../../lexer/comment.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * Dynamicly raises error for missing and required attributes
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function optionalCommentBlockFn($) {
+  return () => {
+    $.sectionStack.push("optionalCommentBlockFn");
+    $.MANY(() => {
+      $.CONSUME(CommentToken);
+      $.CONSUME(NewlineToken);
+    });
+    $.sectionStack.pop();
+  };
+}
+
+/**
+ * Dynamicly raises error for missing and required attributes
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function commentBlockFn($) {
+  return () => {
+    $.sectionStack.push("commentBlockFn");
+    $.AT_LEAST_ONE(() => {
+      $.CONSUME(CommentToken);
+      $.CONSUME(NewlineToken);
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/generic/pipedFilter.js

@@ -0,0 +1,20 @@
+import { ColonToken, PipeToken } from "../../lexer/control.js";
+import { Identifier } from "../../lexer/tokens.js";
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function pipedFilter($) {
+  return () => {
+    // TODO: fix invalid filter name error reporting
+    $.AT_LEAST_ONE(() => {
+      $.CONSUME(PipeToken);
+      $.CONSUME(Identifier);
+      $.MANY1(() => {
+        $.CONSUME(ColonToken);
+        $.SUBRULE($.expressionFn);
+      });
+    });
+  };
+}

package/parser/generic/register.js

@@ -0,0 +1,124 @@
+import { arrayOfObjectAttrReq } from "./arrayOfObjectAttrReq.js";
+import { arrayOfStringLiterals } from "./arrayOfStringLiterals.js";
+import { arrayWithValues } from "./arrayWithValues.js";
+import { assignableVariableAs } from "./assignableVariableAs.js";
+import { assignableVariableProperty } from "./assignableVariableProperty.js";
+import { asVariable } from "./asVariable.js";
+import { booleanValue } from "./booleanValue.js";
+import { bracketAccessor, bracketArrayAccessor } from "./bracketAccessor.js";
+import { castedValue } from "./castedValue.js";
+import {
+  chainedIdentifier,
+  singleChainedIdentifier,
+} from "./chainedIdentifier.js";
+import { completeAuthVariable } from "./completeAuthVariable.js";
+import { completeEnvVariable } from "./completeEnvVariable.js";
+import { completeErrorVariable } from "./completeErrorVariable.js";
+import { completeInputVariable } from "./completeInputVariable.js";
+import { enumValue } from "./enumValue.js";
+import {
+  expressionFn,
+  expressionTestFn,
+  simpleExpressionFn,
+} from "./expressionFn.js";
+import { filterFn } from "./filterFn.js";
+import { functionAttrReq } from "./functionAttrReq.js";
+import { longFormVariable } from "./longFormVariable.js";
+import { minimalFnBody } from "./minimalFnBody.js";
+import { mockAttribute } from "./mockAttribute.js";
+import { multilineFilterFn } from "./multilineFilterFn.js";
+import { numberValue } from "./numberValue.js";
+import { objectAttrReq } from "./objectAttrReq.js";
+import { objectWithAttributes } from "./objectWithAttributes.js";
+import {
+  commentBlockFn,
+  optionalCommentBlockFn,
+} from "./optionalCommentBlock.js";
+import { pipedFilter } from "./pipedFilter.js";
+import { requiredValueFnBody } from "./requiredValueFnBody.js";
+import { shortFormVariable } from "./shortFormVariable.js";
+import { stringArray } from "./stringArray.js";
+import { tagsAttribute } from "./tagsAttribute.js";
+import { valueExpressionForResponse } from "./valueExpressionForResponse.js";
+import { variableOnly } from "./variableOnly.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.mockAttribute = $.RULE("mockAttribute", mockAttribute($));
+  $.arrayOfObjectAttrReq = $.RULE(
+    "arrayOfObjectAttrReq",
+    arrayOfObjectAttrReq($)
+  );
+  $.arrayOfStringLiterals = $.RULE(
+    "arrayOfStringLiterals",
+    arrayOfStringLiterals($)
+  );
+  $.arrayWithValues = $.RULE("arrayWithValues", arrayWithValues($));
+  $.assignableVariableAs = $.RULE(
+    "assignableVariableAs",
+    assignableVariableAs($)
+  );
+  $.assignableVariableProperty = $.RULE(
+    "assignableVariableProperty",
+    assignableVariableProperty($)
+  );
+  $.booleanValue = $.RULE("booleanValue", booleanValue($));
+  $.castedValue = $.RULE("castedValue", castedValue($));
+  $.chainedIdentifier = $.RULE("chainedIdentifier", chainedIdentifier($));
+  $.singleChainedIdentifier = $.RULE(
+    "singleChainedIdentifier",
+    singleChainedIdentifier($)
+  );
+  $.enumValue = $.RULE("enumValue", enumValue($));
+  $.expressionFn = $.RULE("expressionFn", expressionFn($));
+  $.simpleExpressionFn = $.RULE("simpleExpressionFn", simpleExpressionFn($));
+  $.expressionTestFn = $.RULE("expressionTestFn", expressionTestFn($));
+  $.functionAttrReq = $.RULE("functionAttrReq", functionAttrReq($));
+  $.filterFn = $.RULE("filterFn", filterFn($));
+  $.multilineFilterFn = $.RULE("multilineFilterFn", multilineFilterFn($));
+  $.longFormVariable = $.RULE("longFormVariable", longFormVariable($));
+  $.minimalFnBody = $.RULE("minimalFnBody", minimalFnBody($));
+  $.numberValue = $.RULE("numberValue", numberValue($));
+  $.objectAttrReq = $.RULE("objectAttrReq", objectAttrReq($));
+  $.objectWithAttributes = $.RULE(
+    "objectWithAttributes",
+    objectWithAttributes($)
+  );
+  $.pipedFilter = $.RULE("pipedFilter", pipedFilter($));
+  $.requiredValueFnBody = $.RULE("requiredValueFnBody", requiredValueFnBody($));
+  $.shortFormVariable = $.RULE("shortFormVariable", shortFormVariable($));
+  $.stringArray = $.RULE("stringArray", stringArray($));
+  $.tagsAttribute = $.RULE("tagsAttribute", tagsAttribute($));
+  $.expressionFnForResponse = $.RULE(
+    "valueExpressionForResponse",
+    valueExpressionForResponse($)
+  );
+  $.variableOnly = $.RULE("variableOnly", variableOnly($));
+  $.completeAuthVariable = $.RULE(
+    "completeAuthVariable",
+    completeAuthVariable($)
+  );
+  $.bracketAccessor = $.RULE("bracketAccessor", bracketAccessor($));
+  $.bracketArrayAccessor = $.RULE(
+    "bracketArrayAccessor",
+    bracketArrayAccessor($)
+  );
+  $.completeInputVariable = $.RULE(
+    "completeInputVariable",
+    completeInputVariable($)
+  );
+  $.completeErrorVariable = $.RULE(
+    "completeErrorVariable",
+    completeErrorVariable($)
+  );
+  $.completeEnvVariable = $.RULE("completeEnvVariable", completeEnvVariable($));
+  $.asVariable = $.RULE("asVariable", asVariable($));
+  $.optionalCommentBlockFn = $.RULE(
+    "optionalCommentBlockFn",
+    optionalCommentBlockFn($)
+  );
+  $.commentBlockFn = $.RULE("commentBlockFn", commentBlockFn($));
+};

package/parser/generic/requiredValueFnBody.js

@@ -0,0 +1,40 @@
+import { LCurly, RCurly } from "../../lexer/control.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * {
+ *   value = ""
+ * } as x6
+ * To be used when the body of a function only requires a value field
+ * and can be disabled and have an optional description.
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function requiredValueFnBody($) {
+  return () => {
+    $.sectionStack.push("requiredValueFnBody");
+    let hasValue = false;
+
+    $.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/generic/requiredValueFnBody.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) {
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.requiredValueFnBody();
+  return parser;
+}
+
+describe("requiredValueFnBody", () => {
+  it("requiredValueFnBody accepts a value", () => {
+    const parser = parse(`{
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("requiredValueFnBody accepts a description", () => {
+    const parser = parse(`{
+      value = "text"
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("requiredValueFnBody can be disabled", () => {
+    const parser = parse(`{
+      value = "text"
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("requiredValueFnBody accepts a long form variable", () => {
+    const parser = parse(`{
+      value = $var.x1
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("requiredValueFnBody accepts a long form variable with property", () => {
+    const parser = parse(`{
+      value = $var.x1[0].foo
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("requiredValueFnBody requires a value", () => {
+    const parser = parse(`{
+      description = "foo"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/shortFormVariable.js

@@ -0,0 +1,17 @@
+import { ShortFormVariable } from "../../lexer/variables.js";
+
+/**
+ * matches the short form variable definition like:
+ * $x
+ * $x.y.z
+ * $x[1].y
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function shortFormVariable($) {
+  return () => {
+    $.CONSUME(ShortFormVariable);
+    $.SUBRULE($.chainedIdentifier);
+  };
+}

package/parser/generic/shortFormVariable.spec.js

@@ -0,0 +1,27 @@
+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.shortFormVariable();
+  return parser;
+}
+
+describe("shortFormVariable", () => {
+  it("shortFormVariable accept an identifier", () => {
+    const parser = parse("$value");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("shortFormVariable can be a double $$", () => {
+    const parser = parse("$$");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("shortFormVariable cannot start with a number", () => {
+    const parser = parse("$1");
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/stringArray.js

@@ -0,0 +1,33 @@
+import { CommaToken, LSquare, RSquare } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * ["active", "inactive"]
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const stringArray = ($) => () => {
+  let hasSeparator = true; // allow a trailing comma
+  let token = $.CONSUME(LSquare); // "["
+  $.MANY(() => $.CONSUME(NewlineToken)); // allow new lines after the opening bracket
+  $.MANY1(() => {
+    if (!hasSeparator) {
+      $.addMissingError(
+        token,
+        "Missing comma or newline between string values in the array"
+      );
+    }
+    token = $.CONSUME(StringLiteral);
+    hasSeparator = false;
+    $.OPTION(() => {
+      $.CONSUME(CommaToken);
+      hasSeparator = true;
+    }); // ","
+    $.MANY2(() => {
+      $.CONSUME1(NewlineToken);
+      hasSeparator = true;
+    }); // "\n"
+  });
+  $.CONSUME(RSquare); // "]"
+};

package/parser/generic/stringArray.spec.js

@@ -0,0 +1,55 @@
+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.stringArray();
+  return parser;
+}
+
+describe("stringArray", () => {
+  it("stringArray accepts a single string literal", () => {
+    const parser = parse('[ "some string" ]');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("stringArray can be compact", () => {
+    const parser = parse('["some string"]');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("stringArray can be empty", () => {
+    const parser = parse("[]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("stringArray accepts multiple string literal", () => {
+    const parser = parse('["some string", "another string"]');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("stringArray rejects digits", () => {
+    const parser = parse("[123.32]");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("stringArray rejects boolean", () => {
+    const parser = parse("[true]");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("stringArray rejects identifier", () => {
+    const parser = parse("[someString]");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("stringArray accepts a multi-line array", () => {
+    const parser = parse(`[
+      "some string",
+      "another string"
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/tagsAttribute.js

@@ -0,0 +1,14 @@
+import { EqualToken } from "../../lexer/control.js";
+import { TagsToken } from "../../lexer/tokens.js";
+
+/**
+ * tags = ["active", "inactive"]
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function tagsAttribute($) {
+  return () => {
+    $.CONSUME(TagsToken); // "tags"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.stringArray); // ["active", "inactive"]
+  };
+}