@xano/xanoscript-language-server 11.12.2 → 12.0.0

package/parser/generic/arrayWithValues.spec.js

@@ -1,72 +0,0 @@
-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.spec.js

@@ -1,117 +0,0 @@
-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;
-  });
-
-  // Blacklisted variable names - these conflict with built-in variables
-  // Some are blocked at lexer level (separate tokens), others at parser level
-  describe("blacklisted variable names", () => {
-    // These are lexed as ShortFormVariable and need explicit blacklisting
-    const shortFormBlacklisted = ["output", "db", "toolset"];
-
-    for (const name of shortFormBlacklisted) {
-      it(`rejects as $${name} (short form)`, () => {
-        const parser = parse(`as $${name}`);
-        expect(parser.errors).to.be.empty;
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // These are separate tokens and already rejected by the parser
-    const separateTokenBlacklisted = [
-      "auth",
-      "input",
-      "env",
-      "response",
-      "error",
-      "this",
-    ];
-
-    for (const name of separateTokenBlacklisted) {
-      it(`rejects as $${name} (separate token)`, () => {
-        const parser = parse(`as $${name}`);
-        expect(parser.warnings).to.not.be.empty;
-      });
-    }
-
-    // $var is the LongFormVariable prefix, parser expects a dot after it
-    // FIXME: shoud be a warning, not an error, since it's still a valid variable name (albeit confusing)
-    it("rejects as $var (long form prefix)", () => {
-      const parser = parse("as $var");
-      expect(parser.errors).to.be.empty;
-      expect(parser.warnings).to.not.be.empty;
-    });
-
-    // All blacklisted names should be rejected in long form ($var.name)
-    const allBlacklisted = [
-      "auth",
-      "input",
-      "env",
-      "response",
-      "output",
-      "var",
-      "db",
-      "error",
-      "toolset",
-      "this",
-    ];
-
-    for (const name of allBlacklisted) {
-      it(`rejects as $var.${name} (long form)`, () => {
-        const parser = parse(`as $var.${name}`);
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // Ensure valid names still work
-    it("accepts as $user", () => {
-      const parser = parse("as $user");
-      expect(parser.warnings).to.be.empty;
-    });
-
-    it("accepts as $my_input", () => {
-      const parser = parse("as $my_input");
-      expect(parser.errors).to.be.empty;
-      expect(parser.warnings).to.be.empty;
-    });
-
-    it("accepts as $var.my_var", () => {
-      const parser = parse("as $var.my_var");
-      expect(parser.warnings).to.be.empty;
-    });
-  });
-});

package/parser/generic/assignableVariableAs.spec.js

@@ -1,126 +0,0 @@
-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 should warn on $var reserved variable names", () => {
-    const parser = parse("$var");
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).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;
-  });
-
-  // Blacklisted variable names - used in loop contexts (each as $variable)
-  describe("blacklisted variable names", () => {
-    // These are lexed as ShortFormVariable and need explicit blacklisting
-    const shortFormBlacklisted = [
-      "output",
-      "db",
-      "toolset",
-      "auth",
-      "input",
-      "env",
-      "response",
-      "output",
-      "var",
-      "db",
-      "error",
-      "toolset",
-      "this",
-    ];
-
-    for (const name of shortFormBlacklisted) {
-      it(`warns on $${name} (short form)`, () => {
-        const parser = parse(`$${name}`);
-        expect(parser.errors).to.be.empty;
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // All blacklisted names should be rejected in long form ($var.name)
-    const allBlacklisted = [
-      "auth",
-      "input",
-      "env",
-      "response",
-      "output",
-      "var",
-      "db",
-      "error",
-      "toolset",
-      "this",
-    ];
-
-    for (const name of allBlacklisted) {
-      it(`warns on $var.${name} (long form)`, () => {
-        const parser = parse(`$var.${name}`);
-        expect(parser.errors).to.be.empty;
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // Ensure valid names still work
-    it("accepts $item", () => {
-      const parser = parse("$item");
-      expect(parser.errors).to.be.empty;
-    });
-
-    it("accepts $i", () => {
-      const parser = parse("$i");
-      expect(parser.errors).to.be.empty;
-    });
-
-    it("accepts $var.my_var", () => {
-      const parser = parse("$var.my_var");
-      expect(parser.errors).to.be.empty;
-    });
-  });
-});

package/parser/generic/assignableVariableProperty.spec.js

@@ -1,138 +0,0 @@
-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 should warn on $env variable", () => {
-    const parser = parse("$env.my_api_key");
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).to.not.be.empty;
-    expect(parser.warnings[0].message).to.include("reserved");
-  });
-
-  it("assignableVariableProperty should warn on $input variable", () => {
-    const parser = parse("$input.remote_ip");
-    expect(parser.errors).to.be.empty;
-    expect(parser.warnings).to.not.be.empty;
-    expect(parser.warnings[0].message).to.include("reserved");
-  });
-
-  it("assignableVariableProperty cannot be an indentifier", () => {
-    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;
-  });
-
-  // Blacklisted variable names - these conflict with built-in variables
-  // Some are blocked at lexer level (separate tokens), others at parser level
-  describe("blacklisted variable names", () => {
-    // These are lexed as ShortFormVariable and need explicit blacklisting
-    const shortFormBlacklisted = ["output", "db", "toolset"];
-
-    for (const name of shortFormBlacklisted) {
-      it(`rejects $${name} as assignable variable (short form)`, () => {
-        const parser = parse(`$${name}`);
-        expect(parser.errors).to.be.empty;
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // These are separate tokens and already rejected by the parser
-    // (not in the OR alternatives of assignableVariableProperty)
-    const separateTokenBlacklisted = [
-      "auth",
-      "input",
-      "env",
-      "response",
-      "error",
-      "this",
-    ];
-
-    for (const name of separateTokenBlacklisted) {
-      it(`rejects $${name} as assignable variable (separate token)`, () => {
-        const parser = parse(`$${name}`);
-        expect(parser.errors).to.be.empty;
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // $var is the LongFormVariable prefix, parser expects a dot after it
-    it("warns when using $var as assignable variable (long form prefix)", () => {
-      const parser = parse("$var");
-      expect(parser.errors).to.be.empty;
-      expect(parser.warnings).to.not.be.empty;
-    });
-
-    // All blacklisted names should be rejected in long form ($var.name)
-    const allBlacklisted = [
-      "auth",
-      "input",
-      "env",
-      "response",
-      "output",
-      "var",
-      "db",
-      "error",
-      "toolset",
-      "this",
-    ];
-
-    for (const name of allBlacklisted) {
-      it(`rejects $var.${name} as assignable variable (long form)`, () => {
-        const parser = parse(`$var.${name}`);
-        expect(parser.errors).to.be.empty;
-        expect(parser.warnings).to.not.be.empty;
-        expect(parser.warnings[0].message).to.include("reserved");
-      });
-    }
-
-    // Ensure valid names still work
-    it("accepts $user as assignable variable", () => {
-      const parser = parse("$user");
-      expect(parser.errors).to.be.empty;
-    });
-
-    it("accepts $my_input as assignable variable", () => {
-      const parser = parse("$my_input");
-      expect(parser.errors).to.be.empty;
-    });
-
-    it("accepts $var.my_var as assignable variable", () => {
-      const parser = parse("$var.my_var");
-      expect(parser.errors).to.be.empty;
-    });
-  });
-});

package/parser/generic/castedValue.spec.js

@@ -1,29 +0,0 @@
-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.spec.js

@@ -1,89 +0,0 @@
-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.spec.js

@@ -1,23 +0,0 @@
-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.spec.js

@@ -1,99 +0,0 @@
-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 accepts $http_headers without property access", () => {
-    const parser = parse("$env.$http_headers");
-    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;
-  });
-});