@xano/xanoscript-language-server 11.0.3

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

package/parser/generic/booleanValue.js

@@ -0,0 +1,22 @@
+import { FalseToken, TrueToken } from "../../lexer/tokens.js";
+
+/**
+ * A boolean value parser that matches either `true` or `false`.
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function booleanValue($) {
+  return () => {
+    $.OR([
+      {
+        ALT: () => {
+          $.CONSUME(TrueToken);
+        },
+      },
+      {
+        ALT: () => {
+          $.CONSUME(FalseToken);
+        },
+      },
+    ]);
+  };
+}

package/parser/generic/bracketAccessor.js

@@ -0,0 +1,53 @@
+import { LSquare, RSquare } from "../../lexer/control.js";
+import { IntegerLiteral } from "../../lexer/literal.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * to be used after a variable to reference their properties
+ * like foo.bar.x[1].y[2].z
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function bracketAccessor($) {
+  return () => {
+    $.CONSUME(LSquare);
+    $.SUBRULE($.expressionFn);
+    $.CONSUME(RSquare);
+  };
+}
+
+/**
+ * Slightly adjusted bracket accessor for array accessors only
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function bracketArrayAccessor($) {
+  return () => {
+    $.OR([
+      {
+        ALT: () => {
+          $.CONSUME(LSquare);
+          $.SUBRULE($.expressionFn);
+          $.CONSUME(RSquare);
+        },
+      },
+      {
+        ALT: () => {
+          $.CONSUME(DotToken);
+          $.OR1([
+            {
+              ALT: () => $.CONSUME(IntegerLiteral),
+            },
+            {
+              ALT: () => {
+                $.CONSUME1(LSquare);
+                $.SUBRULE1($.expressionFn);
+                $.CONSUME1(RSquare);
+              },
+            },
+          ]);
+        },
+      },
+    ]);
+  };
+}

package/parser/generic/castedValue.js

@@ -0,0 +1,14 @@
+import { CastTokens } from "../../lexer/cast.js";
+import { StringLiteral } from "../../lexer/literal.js";
+
+/**
+ * represent a casted value, e.g., !int "42"
+ * not that we only allow string literals to be casted
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function castedValue($) {
+  return () => {
+    $.OR(CastTokens.map((token) => ({ ALT: () => $.CONSUME(token) })));
+    $.CONSUME(StringLiteral);
+  };
+}

package/parser/generic/castedValue.spec.js

@@ -0,0 +1,29 @@
+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.castedValue();
+  return parser;
+}
+
+describe("castedValue", () => {
+  it("castedValue can be empty", () => {
+    const parser = parse('!int ""');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("castedValue can be a string with new lines", () => {
+    const parser = parse(
+      '!text "[\\n  1,\\n  2,\\n  3,\\n  4,\\n  5,\\n  6,\\n  6\\n]"'
+    );
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("castedValue an array value", () => {
+    const parser = parse('!array "[]"');
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/chainedIdentifier.js

@@ -0,0 +1,48 @@
+import { IntegerLiteral } from "../../lexer/literal.js";
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+import { ShortFormVariable } from "../../lexer/variables.js";
+
+/**
+ * to be used after a variable to reference their properties
+ * like foo.bar.x[1].y[2].z
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function chainedIdentifier($) {
+  return () => {
+    $.MANY(() => $.SUBRULE($.singleChainedIdentifier));
+  };
+}
+
+/**
+ * to be used after a variable to reference a single property depth
+ * like foo.bar , foo[1] or foo["key"]
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function singleChainedIdentifier($) {
+  return () => {
+    $.OR([
+      {
+        ALT: () => {
+          $.CONSUME(DotToken);
+          $.OR1([
+            {
+              ALT: () => {
+                const token = $.CONSUME(ShortFormVariable);
+                $.addWarning(
+                  `Using \`$\` prefixed properties '${token.image}' is discouraged.`,
+                  token
+                );
+              },
+            }, // e.g., .bar
+            { ALT: () => $.CONSUME(Identifier) }, // e.g., .bar
+            { ALT: () => $.CONSUME2(IntegerLiteral) }, // e.g., .3
+            { ALT: () => $.SUBRULE($.bracketAccessor) }, // e.g., .["key"]
+          ]);
+        },
+      },
+      { ALT: () => $.SUBRULE1($.bracketAccessor) }, // e.g., .["key"]
+    ]);
+  };
+}

package/parser/generic/chainedIdentifier.spec.js

@@ -0,0 +1,89 @@
+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.chainedIdentifier();
+  return parser;
+}
+
+describe("chainedIdentifier", () => {
+  it("chainedIdentifier empty", () => {
+    const parser = parse("");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a dot value", () => {
+    const parser = parse(".x");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier an array index", () => {
+    const parser = parse("[12]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a hash index", () => {
+    const parser = parse(`["key"]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier an expression context index", () => {
+    const parser = parse("[$$]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a variable as array index", () => {
+    const parser = parse("[$var.index]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a string literal as a hash property index", () => {
+    let parser = parse(`[$var.["property"]]`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`[$var["property"]]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a input as array index", () => {
+    const parser = parse("[$input.index]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a shorthand variable as an array index", () => {
+    const parser = parse("[$index]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier could reference properties starting with $", () => {
+    let parser = parse(".$index");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(".foo.$bar");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(".2.$bar");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse("[$index].$bar");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a dot value and array index", () => {
+    const parser = parse(".x[1]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a dot value and array index", () => {
+    const parser = parse(".x.2.y");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("chainedIdentifier a dot value and array index and value", () => {
+    const parser = parse(".x[1].y.z[2]");
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/completeAuthVariable.js

@@ -0,0 +1,13 @@
+import { AuthVariable } from "../../lexer/variables.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function completeAuthVariable($) {
+  return () => {
+    $.CONSUME(AuthVariable);
+    $.SUBRULE($.chainedIdentifier);
+  };
+}

package/parser/generic/completeAuthVariable.spec.js

@@ -0,0 +1,23 @@
+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.completeAuthVariable();
+  return parser;
+}
+
+describe("completeAuthVariable", () => {
+  it("completeAuthVariable accepts auth variable", () => {
+    const parser = parse("$auth.user_id");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeAuthVariable accepts auth variable with custom properties", () => {
+    const parser = parse("$auth.custom.property.name");
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/completeEnvVariable.js

@@ -0,0 +1,79 @@
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+import {
+  ApiBaseUrlVariable,
+  BranchVariable,
+  DatasourceVariable,
+  EnvVariable,
+  HttpHeadersVariable,
+  RemoteHostVariable,
+  RemoteIpVariable,
+  RemotePasswordVariable,
+  RemotePortVariable,
+  RemoteUserVariable,
+  RequestAuthTokenVariable,
+  RequestMethod,
+  RequestQuerystringVariable,
+  RequestUriVariable,
+  ShortFormVariable,
+  TenantVariable,
+  WebflowVariable,
+} from "../../lexer/variables.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function completeEnvVariable($) {
+  return () => {
+    $.CONSUME(EnvVariable);
+    $.OR([
+      {
+        ALT: () => {
+          $.CONSUME(DotToken);
+          $.OR1([
+            { ALT: () => $.CONSUME(ApiBaseUrlVariable) },
+            { ALT: () => $.CONSUME(BranchVariable) },
+            { ALT: () => $.CONSUME(DatasourceVariable) },
+            {
+              ALT: () => {
+                $.CONSUME(HttpHeadersVariable);
+                $.SUBRULE($.singleChainedIdentifier);
+              },
+            },
+            { ALT: () => $.CONSUME(RemoteHostVariable) },
+            { ALT: () => $.CONSUME(RemoteIpVariable) },
+            { ALT: () => $.CONSUME(RemotePasswordVariable) },
+            { ALT: () => $.CONSUME(RemotePortVariable) },
+            { ALT: () => $.CONSUME(RemoteUserVariable) },
+            { ALT: () => $.CONSUME(RequestAuthTokenVariable) },
+            { ALT: () => $.CONSUME(RequestMethod) },
+            { ALT: () => $.CONSUME(RequestQuerystringVariable) },
+            { ALT: () => $.CONSUME(RequestUriVariable) },
+            { ALT: () => $.CONSUME(TenantVariable) },
+            {
+              ALT: () => {
+                $.CONSUME(WebflowVariable);
+                $.SUBRULE1($.singleChainedIdentifier);
+              },
+            },
+            { ALT: () => $.CONSUME(Identifier) }, // environment variable don't have subfields
+            {
+              ALT: () => {
+                const token = $.CONSUME(ShortFormVariable);
+                $.addWarning(
+                  `Using \`$\` prefixed environment variables '${token.image}' is discouraged.`,
+                  token
+                );
+              },
+            },
+            { ALT: () => $.SUBRULE($.bracketAccessor) }, // e.g., .["key" ]
+          ]);
+        },
+      },
+      {
+        ALT: () => $.SUBRULE1($.bracketAccessor),
+      },
+    ]);
+  };
+}

package/parser/generic/completeEnvVariable.spec.js

@@ -0,0 +1,94 @@
+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.completeEnvVariable();
+  return parser;
+}
+
+describe("completeEnvVariable", () => {
+  it("completeEnvVariable accepts environment variable", () => {
+    const parser = parse("$env.MY_VARIABLE");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts remote address variable", () => {
+    const parser = parse("$env.$remote_ip");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts webflow", () => {
+    const parser = parse("$env.$webflow.api_base_url");
+    expect(parser.errors).to.be.empty;
+  });
+
+  // $env.$remote_passwd
+  it("completeEnvVariable accepts remote password variable", () => {
+    const parser = parse("$env.$remote_passwd");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts remote port variable", () => {
+    const parser = parse("$env.$remote_port");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts remote user variable", () => {
+    const parser = parse("$env.$remote_user");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts remote host variable", () => {
+    const parser = parse("$env.$remote_host");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts request method variable", () => {
+    const parser = parse("$env.$request_method");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts tenant variable", () => {
+    const parser = parse("$env.$tenant");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable accepts tenant variable", () => {
+    const parser = parse("$env.$http_headers.Referer");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeEnvVariable warn when using env variable starting with $", () => {
+    const parser = parse("$env.$my_custom_variable");
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).not.to.be.empty;
+  });
+
+  it("completeEnvVariable rejects property name format", () => {
+    let parser = parse('$env.$http_headers["Content-Type"]');
+    expect(parser.errors).to.be.empty;
+    parser = parse("$env.$http_headers.Content-Type");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("completeEnvVariable can access env variable using other variable value", () => {
+    let parser = parse("$env.$http_headers[$input.header_name]");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse("$env.[$input.header_name]");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse("$env.[$header_name]");
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`$env.["http_headers"]`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`$env["http_headers"]`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/generic/completeErrorVariable.js

@@ -0,0 +1,39 @@
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+import { ErrorVariable } from "../../lexer/variables.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function completeErrorVariable($) {
+  const allowedProperties = new Set(["name", "code", "message", "result"]);
+
+  return () => {
+    const parent = $.CONSUME(ErrorVariable);
+
+    if (!$.sectionStack.includes("catchFn")) {
+      $.addInvalidValueError(
+        parent,
+        `Invalid use of $error variable outside of a catch block.`
+      );
+    }
+
+    $.OPTION(() => {
+      $.CONSUME(DotToken);
+      const property = $.CONSUME(Identifier);
+
+      if (!allowedProperties.has(property.image)) {
+        $.addInvalidValueError(
+          property,
+          `Invalid property '${
+            property.image
+          }' for $error variable. Allowed properties are: ${Array.from(
+            allowedProperties
+          ).join(", ")}.`
+        );
+      }
+      $.SUBRULE($.chainedIdentifier);
+    });
+  };
+}

package/parser/generic/completeErrorVariable.spec.js

@@ -0,0 +1,17 @@
+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.completeErrorVariable();
+  return parser;
+}
+
+describe("completeErrorVariable", () => {
+  it("completeErrorVariable does not work outside a try catch block", () => {
+    let parser = parse("$error.result.first");
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/generic/completeInputVariable.js

@@ -0,0 +1,42 @@
+import { LSquare, RSquare } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { DotToken, Identifier } from "../../lexer/tokens.js";
+import { InputVariable } from "../../lexer/variables.js";
+
+/**
+ *
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function completeInputVariable($) {
+  return () => {
+    $.CONSUME(InputVariable);
+    $.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/completeInputVariable.spec.js

@@ -0,0 +1,53 @@
+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.completeInputVariable();
+  return parser;
+}
+
+describe("completeInputVariable", () => {
+  it("completeInputVariable empty", () => {
+    const parser = parse("$input.foo");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeInputVariable a dot value", () => {
+    const parser = parse("$input.x.bar");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeInputVariable an array index", () => {
+    const parser = parse("$input.x[12]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeInputVariable a string as a hash property index", () => {
+    let parser = parse(`$input["value"]`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`$input.["value"]`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`$input.["value"]["bar"].[1]["pie"]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeInputVariable an expression context index", () => {
+    const parser = parse("$input.x[$$]");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("completeInputVariable cannot be referenced without an attribute", () => {
+    const parser = parse("$input");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("completeInputVariable cannot reference an index", () => {
+    const parser = parse("$input[0]");
+    expect(parser.errors).to.not.be.empty;
+  });
+});