@xano/xanoscript-language-server 11.0.3

package/parser/generic/arrayOfObjectAttrReq.spec.js

@@ -0,0 +1,254 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { EqualToken } from "../../lexer/control.js";
+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.arrayOfObjectAttrReq_test_required = this.RULE(
+    "arrayOfObjectAttrReq_test_required",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.arrayOfObjectAttrReq, { ARGS: [name, ["foo"]] });
+    }
+  );
+
+  this.arrayOfObjectAttrReq_test_optionals = this.RULE(
+    "arrayOfObjectAttrReq_test_optionals",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.arrayOfObjectAttrReq, {
+        ARGS: [name, [], ["foo", "bar"]],
+      });
+    }
+  );
+
+  this.arrayOfObjectAttrReq_test_index = this.RULE(
+    "arrayOfObjectAttrReq_test_index",
+    () => {
+      const parent = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.arrayOfObjectAttrReq, {
+        ARGS: [
+          parent,
+          ["type", "field"],
+          [],
+          {
+            types: {
+              type: "string",
+            },
+          },
+        ],
+      });
+    }
+  );
+
+  this.arrayOfObjectAttrReq_test_recursive_value = this.RULE(
+    "test_recursive_value",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.arrayOfObjectAttrReq, {
+        ARGS: [
+          name,
+          ["name", "as", "input"],
+          ["addon"],
+          { recursive: ["addon"] },
+        ],
+      });
+    }
+  );
+  this.arrayOfObjectAttrReq_test_recursive_array_addon = this.RULE(
+    "test_recursive_array_addon",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.arrayOfObjectAttrReq, {
+        ARGS: [
+          name,
+          ["name", "as", "input"],
+          ["addon"],
+          { recursiveArray: ["addon"] },
+        ],
+      });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("arrayOfObjectAttrReq", () => {
+  it("arrayOfObjectAttrReq accepts required attribute", () => {
+    parse(`something = [ {foo: "true"}]`).arrayOfObjectAttrReq_test_required();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq accepts multilines attributes", () => {
+    parse(`something = [ 
+      {
+        foo: true
+        bar: 12
+      }
+    ]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq accepts list of single lines", () => {
+    parse(`something = [ 
+      {foo: true, bar: 12}
+    ]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq accepts multiple values", () => {
+    parse(`something = [ 
+      {
+        foo: true
+      }
+      {
+        bar: 12
+      }
+    ]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+
+    parse(
+      `something = [{ foo: true }, {bar: 12}]`
+    ).arrayOfObjectAttrReq_test_optionals();
+  });
+
+  it("arrayOfObjectAttrReq detects missing required attribute", () => {
+    parse(`something = [ {}]`).arrayOfObjectAttrReq_test_required();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq allow for recursive definition", () => {
+    parse(`addon = [
+      {
+        name : "client"
+        as   : "_client"
+        input: {client_id: ""}
+        addon: {
+          name : "client"
+          as   : "_client"
+          input: {client_id: ""}
+          addon: {
+            name : "client"
+            as   : "_client"
+            input: {client_id: ""}
+          }
+        }
+      }
+    ]`).arrayOfObjectAttrReq_test_recursive_value();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq detects missing definition on recursive attributes", () => {
+    parse(`addon = [
+      {
+        name : "client"
+        as   : "_client"
+        input: {client_id: ""}
+        addon: {
+          name : "client"
+          input: {client_id: ""}
+        }
+      }
+    ]`).arrayOfObjectAttrReq_test_recursive_value();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq allow for recursive array", () => {
+    parse(`addon = [
+      {
+        name : "client"
+        as   : "_client"
+        input: {client_id: ""}
+        addon: [
+          {
+            name : "client"
+            as   : "_client"
+            input: {client_id: ""}
+            addon: [
+              {
+                name : "client"
+                as   : "_client"
+                input: {client_id: ""}
+                addon: []
+              }
+            ]
+          }
+        ]
+      }
+    ]`).arrayOfObjectAttrReq_test_recursive_array_addon();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq detects missing definition on recursive array", () => {
+    parse(`addon = [
+      {
+        name : "client"
+        as   : "_client"
+        input: {client_id: ""}
+        addon: [
+          {
+            name : "client"
+            input: {client_id: ""}
+          }
+        ]
+      }
+    ]`).arrayOfObjectAttrReq_test_recursive_array_addon();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq accepts optional attributes", () => {
+    parse(`something = [{}]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [{foo: true}]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [{bar: "ok"}]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+
+    parse(
+      `something = [{bar: "ok", "foo": 12.1}]`
+    ).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [
+      {bar: "ok", "foo": 12.1},
+      {bar: "ok", "foo": 12.1}
+    ]`).arrayOfObjectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq can be used for single line index clause", () => {
+    parse(
+      `index = [{type: "primary", field: [{name: "id"}]}]`
+    ).arrayOfObjectAttrReq_test_index();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfObjectAttrReq can be used for index clause", () => {
+    parse(`index = [
+      {type: "primary", field: [{name: "id"}]}
+      {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
+      {type: "btree", field: [{name: "created_at", op: "desc"}]}
+    ]`).arrayOfObjectAttrReq_test_index();
+    expect(parser.errors).to.be.empty;
+
+    parse(`index = [
+      {type: "primary", field: [{name: "id"}]}
+    ]`).arrayOfObjectAttrReq_test_index();
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/arrayOfStringLiterals.js

@@ -0,0 +1,45 @@
+import { CommaToken, LSquare, RSquare } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * Dynamicly raises error for missing and required attributes
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function arrayOfStringLiterals($) {
+  return () => {
+    $.CONSUME(LSquare); // "["
+    $.OPTION(() => {
+      $.OR([
+        // multi line, each value on a new line
+        // [
+        //   value
+        //   value2
+        // ]
+        {
+          ALT: () => {
+            $.CONSUME(NewlineToken);
+            $.AT_LEAST_ONE(() => {
+              $.CONSUME(StringLiteral);
+              $.OPTION1(() => $.CONSUME(CommaToken)); // optional comma
+              $.AT_LEAST_ONE1(() => $.CONSUME3(NewlineToken));
+            });
+          },
+        },
+        // one line, comma separated [ value, value2 ]
+        {
+          ALT: () => {
+            $.AT_LEAST_ONE_SEP({
+              SEP: CommaToken,
+              DEF: () => {
+                $.CONSUME1(StringLiteral);
+              },
+            });
+            $.MANY(() => $.CONSUME2(NewlineToken));
+          },
+        },
+      ]);
+    });
+    $.CONSUME(RSquare); // "]"
+  };
+}

package/parser/generic/arrayOfStringLiterals.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.arrayOfStringLiterals();
+  return parser;
+}
+
+describe("arrayOfStringLiterals", () => {
+  it("arrayOfStringLiterals accepts a single string ", () => {
+    const parser = parse(`[ "true" ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfStringLiterals can be empty ", () => {
+    const parser = parse(`[]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfStringLiterals can be multilines without trailing commas", () => {
+    const parser = parse(`[
+      "foo"
+      "bar"
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfStringLiterals can be multilines with trailing commas ", () => {
+    const parser = parse(`[
+      "foo",
+      "bar"
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfStringLiterals can be compact ", () => {
+    const parser = parse(`["foo","bar"]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayOfStringLiterals cannot contain a non string ", () => {
+    let parser = parse(`[4]`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`[true]`);
+    expect(parser.errors).to.not.be.empty;
+
+    parser = parse(`["test", 4]`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/arrayWithValues.js

@@ -0,0 +1,35 @@
+import { CommaToken, LSquare, RSquare } from "../../lexer/control.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function arrayWithValues($) {
+  return (options = {}) => {
+    let need_separators = false;
+    const parent = $.CONSUME(LSquare); // "["
+    $.MANY(() => {
+      $.MANY1(() => {
+        need_separators = false;
+        $.CONSUME(NewlineToken);
+      });
+      if (need_separators) {
+        $.addMissingError(CommaToken, "Expected ',' between array values");
+      }
+      $.SUBRULE($.expressionFn, {
+        ARGS: [parent, { ...options, allowObject: true, allowArray: true }],
+      });
+      need_separators = true;
+      $.OPTION1(() => {
+        need_separators = false;
+        $.CONSUME1(CommaToken);
+      });
+      $.MANY2(() => {
+        need_separators = false;
+        $.CONSUME1(NewlineToken);
+      });
+    });
+
+    $.CONSUME(RSquare); // "]"
+  };
+}

package/parser/generic/arrayWithValues.spec.js

@@ -0,0 +1,72 @@
+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.arrayWithValues();
+  return parser;
+}
+
+describe("arrayWithValues", () => {
+  it("arrayWithValues accepts an object as value", () => {
+    const parser = parse(`[ { name: "john"} ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayWithValues accepts a boolean value", () => {
+    const parser = parse(`[ true ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayWithValues accepts null value", () => {
+    const parser = parse(`[ null ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayWithValues accepts multiple values", () => {
+    const parser = parse(`[ 1, 2, 3 ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayWithValues accepts compact multiple values", () => {
+    const parser = parse(`[1,2,3]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayWithValues accepts multiple line object", () => {
+    const parser = parse(`[
+      1
+      2
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  // this means we should be using an empty array rule, not arrayWithValues
+  it("arrayWithValues does not accepts an empty array", () => {
+    const parser = parse(`[]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("arrayWithValues accepts a mix of values and objects", () => {
+    const parser = parse(`[
+        {
+          name : "client"
+          as   : "_client"
+          input: {client_id: ""}
+          addon: [
+            {
+              name  : "client"
+              as    : "_client"
+              offset: "items[]"
+              input : {client_id: $output.id}
+            }
+          ]
+        }
+      ]`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/asVariable.js

@@ -0,0 +1,23 @@
+import { AsToken } from "../../lexer/control.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function asVariable($) {
+  /**
+   * @param {import('chevrotain').IToken} parent
+   **/
+  return (parent) => {
+    let hasAs = false;
+    $.OPTION(() => {
+      hasAs = true;
+      $.CONSUME(AsToken); // "as"
+      $.SUBRULE($.assignableVariableProperty);
+    });
+
+    if (!hasAs && parent) {
+      $.addWarning("`as <variable>` is missing", parent);
+    }
+  };
+}

package/parser/generic/asVariable.spec.js

@@ -0,0 +1,37 @@
+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.asVariable();
+  return parser;
+}
+
+describe("asVariable", () => {
+  it("asVariable should be using a $var", () => {
+    const parser = parse("as $foo");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("asVariable should store the variable name", () => {
+    const parser = parse("as $foo");
+    expect(parser.__symbolTable.var["$foo"]).to.not.be.undefined;
+  });
+
+  it("asVariable should store the variable name", () => {
+    const parser = parse("as $var.bar");
+    expect(parser.__symbolTable.var["$bar"]).to.not.be.undefined;
+  });
+
+  it("asVariable rejects invalid variable names", () => {
+    const parser = parse("as foo");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("asVariable reject double $ sign in variable", () => {
+    const parser = parse("as $$clients");
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/assignableVariableAs.js

@@ -0,0 +1,27 @@
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+import { LongFormVariable,ShortFormVariable } from "../../lexer/variables.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function assignableVariableAs($) {
+  return () => {
+    $.OR([
+      // "$users"
+      {
+        ALT: () => {
+          $.CONSUME(ShortFormVariable);
+        },
+      },
+      // "$var.users"
+      {
+        ALT: () => {
+          $.CONSUME(LongFormVariable);
+          $.CONSUME(DotToken);
+          $.CONSUME(Identifier);
+        },
+      },
+    ]);
+  };
+}

package/parser/generic/assignableVariableAs.spec.js

@@ -0,0 +1,52 @@
+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.assignableVariableAs();
+  return parser;
+}
+
+describe("assignableVariableAs", () => {
+  it("assignableVariableAs can be a short named variable", () => {
+    const parser = parse("$users");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("assignableVariableAs can be a variable", () => {
+    const parser = parse("$var.users");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("assignableVariableAs cannot have a filter", () => {
+    const parser = parse("$var.users|trim");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("assignableVariableAs cannot be a short named variable with sub props", () => {
+    const parser = parse("$users.x.y[1].z");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("assignableVariableAs cannot be a variable with sub props", () => {
+    const parser = parse("$var.users.x.y[1].z");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("assignableVariableAs cannot be an env variable", () => {
+    const parser = parse("$env.my_api_key");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("assignableVariableAs cannot be an input variable", () => {
+    const parser = parse("$input.remote_ip");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("assignableVariableAs cannot be a string", () => {
+    const parser = parse(`"someting"`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/assignableVariableProperty.js

@@ -0,0 +1,52 @@
+import { PipeToken } from "../../lexer/control.js";
+import { DotToken, Identifier, NewlineToken } from "../../lexer/tokens.js";
+import { LongFormVariable, ShortFormVariable } from "../../lexer/variables.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function assignableVariableProperty($) {
+  return () => {
+    let variableName = "";
+    $.OR({
+      DEF: [
+        // "$users"
+        {
+          ALT: () => {
+            const variable = $.CONSUME(ShortFormVariable);
+            variableName = variable.image;
+          },
+        },
+        // "$var.users"
+        {
+          ALT: () => {
+            $.CONSUME(LongFormVariable);
+            $.CONSUME(DotToken);
+            const variable = $.CONSUME(Identifier);
+            variableName = `$${variable.image}`;
+          },
+        },
+      ],
+      ERR_MSG: "expecting variable (e.g. $variable or $var.variable)",
+    });
+    $.SUBRULE($.chainedIdentifier);
+
+    $.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: () => {
+        $.SUBRULE($.filterFn);
+      },
+    });
+
+    if (variableName) {
+      $.addVariable(variableName, "unknown");
+    }
+  };
+}