@xano/xanoscript-language-server 11.0.3

package/onHover/FilterMessageProvider.js

@@ -0,0 +1,102 @@
+import { HoverMessageProvider } from "./HoverMessageProvider.js";
+
+// read the `filters.md` file to gather all the filters
+// each filter starts with `# filter_name`
+export class FilterMessageProvider extends HoverMessageProvider {
+  /**
+   * @param {string} filtersMd
+   */
+  constructor(filtersMd) {
+    super();
+    this.parseFilters(filtersMd);
+  }
+
+  /**
+   * parser a markdown documentation text to extract all the filters
+   * and their documentation
+   * @param {string} content
+   */
+  parseFilters(content) {
+    this.__filterDoc = {};
+    let body = [];
+    let fn = "";
+    for (let line of content.split("\n")) {
+      if (line.startsWith("#")) {
+        // every filter name starts with a '#'
+        if (fn) {
+          this.__filterDoc[fn] = body.join("\n");
+        }
+
+        // remove the leading '#' and trim
+        fn = line.slice(1).trim();
+
+        // if the function starts with '!' it's deprecated
+        // # !old_filter:new_filter
+        if (fn.startsWith("!")) {
+          const [deprecatedFilter, recommended] = fn
+            .slice(1)
+            .split(":")
+            .map((p) => p.trim())
+            .filter((p) => p);
+          if (recommended) {
+            this.__filterDoc[
+              deprecatedFilter
+            ] = `\`${deprecatedFilter}\` is deprecated, use \`${recommended}\` instead.`;
+          }
+          fn = "";
+        }
+
+        body = [];
+      } else {
+        body.push(line);
+      }
+    }
+  }
+
+  /**
+   * find a filter by its index in the token stream
+   * @param {int} index
+   * @param {import("chevrotain").[]} tokens
+   * @returns {string|null} the filter name or null if not found
+   */
+  findFilter(index, tokens) {
+    const token = tokens[index];
+
+    // Check if it's an Identifier token or has Identifier as a category/longer_alt
+    const isIdentifierLike =
+      token.tokenType.name === "Identifier" ||
+      (token.tokenType.LONGER_ALT &&
+        token.tokenType.LONGER_ALT.name === "Identifier") ||
+      (token.tokenType.CATEGORIES &&
+        token.tokenType.CATEGORIES.some((cat) => cat.name === "Identifier"));
+
+    if (!isIdentifierLike) {
+      return null;
+    }
+
+    const name = token.image;
+    if (this.__filterDoc[name]) {
+      return name;
+    }
+
+    return null;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  isMatch(index, tokens, parser) {
+    // a filter always starts with a |
+    if (index === 0 || tokens[index - 1].image !== "|") {
+      return false;
+    }
+
+    return !!this.findFilter(index, tokens);
+  }
+
+  render(index, tokens) {
+    const fn = this.findFilter(index, tokens);
+
+    if (fn) {
+      return this.__filterDoc[fn];
+    }
+  }
+}

package/onHover/FilterMessageProvider.spec.js

@@ -0,0 +1,85 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "../parser/parser.js";
+import { FilterMessageProvider } from "./FilterMessageProvider.js";
+
+const testdoc = `
+# array_push
+does this
+# array_pop
+does that
+# array
+does what
+to who?
+# first
+pick the first element
+# last
+pick the last element
+to who?
+# concat
+Will tape the strings together
+# in
+checks if value is in array
+# !deprecated_filter:array_filter
+Some message here
+`;
+
+describe("FilterMessageProvider", () => {
+  it("should return the message of the function", () => {
+    const messageProvider = new FilterMessageProvider(testdoc);
+    expect(messageProvider.__filterDoc["array_push"]).to.not.be.undefined;
+  });
+
+  it("should parse the functions from the documentation", () => {
+    const messageProvider = new FilterMessageProvider(testdoc);
+
+    expect(messageProvider.__filterDoc["array_push"]).to.equal("does this");
+    expect(messageProvider.__filterDoc["array"]).to.equal("does what\nto who?");
+  });
+
+  it("should display deprecated message on deprecated functions", () => {
+    const messageProvider = new FilterMessageProvider(testdoc);
+    expect(messageProvider.__filterDoc["deprecated_filter"]).to.equal(
+      "`deprecated_filter` is deprecated, use `array_filter` instead."
+    );
+  });
+
+  it("should match the filter name", async () => {
+    const code = `
+function foo {
+  stack {
+    var $value {
+      code = "hello"|concat:" world"
+    }
+    db.query first as $users|first
+  }
+}`;
+    const parser = xanoscriptParser(code.trim());
+    const messageProvider = new FilterMessageProvider(testdoc);
+
+    expect(parser.tokVector[15].image).to.equal("concat");
+    expect(messageProvider.isMatch(15, parser.tokVector)).to.be.true;
+
+    // this first is not a filter, it's table name
+    expect(parser.tokVector[24].image).to.equal("first");
+    expect(messageProvider.isMatch(24, parser.tokVector)).to.be.false;
+
+    expect(parser.tokVector[28].image).to.equal("first");
+    expect(messageProvider.isMatch(28, parser.tokVector)).to.be.true;
+  });
+
+  it("should match even when token is marked as an Identifier as an alternative", async () => {
+    const code = `function foo {
+  stack {
+    var $value {
+      code = "hello"|in:["hello", "world"]
+    }
+  }
+}`;
+    const parser = xanoscriptParser(code);
+    const messageProvider = new FilterMessageProvider(testdoc);
+
+    expect(parser.tokVector[15].image).to.equal("in");
+    expect(messageProvider.isMatch(15, parser.tokVector)).to.be.true;
+  });
+});

package/onHover/FunctionMessageProvider.js

@@ -0,0 +1,122 @@
+import { HoverMessageProvider } from "./HoverMessageProvider.js";
+
+// read the `functions.md` file to gather all the functions
+// each function starts with `# function_name`
+export class FunctionMessageProvider extends HoverMessageProvider {
+  /**
+   * @param {string} functionsMd
+   */
+  constructor(functionsMd) {
+    super();
+
+    this.parseFunctions(functionsMd);
+    this.buildSearchTree();
+  }
+
+  /**
+   * take every functions, break it down into words
+   * and build a search tree in reverse order
+   * api.foo.lambda will be
+   *     {
+   *       lambda: {
+   *         foo: {
+   *           api: {
+   *             __value: "api.foo.lambda"
+   *           }
+   *         }
+   *       }
+   *     }
+   */
+  buildSearchTree() {
+    this.__searchTree = {};
+    for (let fn in this.__functionDoc) {
+      let parts = fn.split(".");
+      let tree = this.__searchTree;
+      for (let i = parts.length - 1; i >= 0; i--) {
+        let part = parts[i];
+        if (!tree[part]) {
+          tree[part] = {};
+        }
+        tree = tree[part];
+      }
+      tree.__value = fn;
+    }
+  }
+
+  /**
+   * parser a markdown documentation text to extract all the functions
+   * and their documentation
+   * @param {string} content
+   */
+  parseFunctions(content) {
+    this.__functionDoc = {};
+    let body = [];
+    let fn = "";
+    for (let line of content.split("\n")) {
+      if (line.startsWith("#")) {
+        if (fn) {
+          this.__functionDoc[fn] = body.join("\n");
+        }
+
+        fn = line.slice(2).trim();
+        body = [];
+      } else {
+        body.push(line);
+      }
+    }
+
+    if (fn && body.length) {
+      this.__functionDoc[fn] = body.join("\n").trim();
+    }
+  }
+
+  /**
+   *
+   * @param {number} index
+   * @param {import('chevrotain').IToken[]} tokens
+   * @param {*} tree
+   * @returns {string} the function documentation
+   */
+  findFunction(index, tokens, tree = null) {
+    if (!tree) {
+      tree = this.__searchTree;
+    }
+
+    const token = tokens[index];
+    const node = tree[token.image];
+
+    if (node) {
+      const prevToken = tokens[index - 1];
+      // if the prev node is a . then we're dealing method of a parent function
+      if (prevToken && prevToken.image === ".") {
+        return this.findFunction(index - 2, tokens, node);
+      }
+
+      if (node.__value) {
+        return node.__value;
+      }
+    }
+
+    return null;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  isMatch(index, tokens, parser) {
+    const next = tokens[index + 1];
+    // if the next token is a . then we're dealing with a method (x.y.z), we'll skip
+    // the function documentation until we find the method
+    if (next && next.image === ".") {
+      return false;
+    }
+
+    return !!this.findFunction(index, tokens);
+  }
+
+  render(index, tokens) {
+    const fn = this.findFunction(index, tokens);
+
+    if (fn) {
+      return this.__functionDoc[fn];
+    }
+  }
+}

package/onHover/FunctionMessageProvider.spec.js

@@ -0,0 +1,128 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "../parser/parser.js";
+import { FunctionMessageProvider } from "./FunctionMessageProvider.js";
+
+const testdoc = `
+# api.lambda
+does this
+# test.lambda
+does this
+# api.foo.lambda
+does that
+# lambda
+does that
+and that
+# api
+does that
+# $var
+a variable
+`;
+
+describe("FunctionMessageProvider", () => {
+  it("should return the message of the function", () => {
+    const messageProvider = new FunctionMessageProvider(testdoc);
+    expect(messageProvider.__functionDoc["api.lambda"]).to.not.be.undefined;
+  });
+
+  it("should define the $var", () => {
+    const messageProvider = new FunctionMessageProvider(testdoc);
+    expect(messageProvider.__functionDoc["$var"]).to.not.be.undefined;
+  });
+
+  it("should parse the functions from the documentation", () => {
+    const messageProvider = new FunctionMessageProvider(testdoc);
+
+    expect(messageProvider.__functionDoc["api.lambda"]).to.equal("does this");
+    expect(messageProvider.__functionDoc["lambda"]).to.equal(
+      "does that\nand that"
+    );
+  });
+
+  it("should match the function name", async () => {
+    const code = `function foo {
+  stack {
+    api.lambda {
+      code = "console.log('hello')"
+    }
+    foo.lambda {
+      code = "console.log('hello')"
+    }
+    lambda {
+      code = "console.log('hello')"
+    }
+  }
+}`;
+    const parser = xanoscriptParser(code);
+    const messageProvider = new FunctionMessageProvider(testdoc);
+
+    expect(parser.tokVector[9].image).to.equal("lambda");
+    expect(messageProvider.isMatch(9, parser.tokVector)).to.be.true;
+
+    expect(parser.tokVector[7].image).to.equal("api");
+    expect(messageProvider.isMatch(7, parser.tokVector)).to.be.false;
+
+    expect(parser.tokVector[20].image).to.equal("lambda");
+    expect(messageProvider.isMatch(20, parser.tokVector)).to.be.false;
+
+    expect(parser.tokVector[29].image).to.equal("lambda");
+    expect(messageProvider.isMatch(29, parser.tokVector)).to.be.true;
+  });
+
+  it("should build a search tree", () => {
+    const messageProvider = new FunctionMessageProvider(testdoc);
+    expect(messageProvider.__searchTree).to.deep.equal({
+      lambda: {
+        __value: "lambda",
+        test: {
+          __value: "test.lambda",
+        },
+        api: {
+          __value: "api.lambda",
+        },
+        foo: {
+          api: { __value: "api.foo.lambda" },
+        },
+      },
+      $var: {
+        __value: "$var",
+      },
+      api: {
+        __value: "api",
+      },
+    });
+  });
+
+  it("should find the correct match", async () => {
+    const code = `function foo {
+      stack {
+        api.lambda {
+          code = "console.log('hello')"
+        }
+        lambda {
+          code = "console.log('hello')"
+        }
+        api.foo.lambda {
+          code = "console.log('hello')"
+        }
+      }
+    }`;
+    const parser = xanoscriptParser(code);
+    const messageProvider = new FunctionMessageProvider(testdoc);
+
+    expect(parser.tokVector[9].image).to.equal("lambda");
+    expect(messageProvider.findFunction(9, parser.tokVector)).to.equal(
+      "api.lambda"
+    );
+
+    expect(parser.tokVector[18].image).to.equal("lambda");
+    expect(messageProvider.findFunction(18, parser.tokVector)).to.equal(
+      "lambda"
+    );
+
+    expect(parser.tokVector[31].image).to.equal("lambda");
+    expect(messageProvider.findFunction(31, parser.tokVector)).to.equal(
+      "api.foo.lambda"
+    );
+  });
+});

package/onHover/HoverMessageProvider.js

@@ -0,0 +1,31 @@
+export class HoverMessageProvider {
+  constructor() {
+    this.message = "";
+    this.range = null;
+  }
+
+  /**
+   * checks if the hover message matches the token at the given
+   * index
+   * @param {number} index
+   * @param {import('chevrotain').IToken[]} tokens
+   * @param {import('../parser/base_parser.js').XanoBaseParser} parser
+   * @returns {boolean} whether the token at the given index matches the hover message
+   */
+  // eslint-disable-next-line no-unused-vars
+  isMatch(index, tokens, parser) {
+    return false;
+  }
+
+  /**
+   * renders the hover message
+   * @param {number} index
+   * @param {import('chevrotain').IToken[]} tokens
+   * @param {import('../parser/base_parser').XanoBaseParser} parser
+   * @returns {string}
+   */
+  // eslint-disable-next-line no-unused-vars
+  render(index, tokens, parser) {
+    return this.message;
+  }
+}

package/onHover/InputFilterMessageProvider.js

@@ -0,0 +1,140 @@
+import { HoverMessageProvider } from "./HoverMessageProvider.js";
+
+// read the `filters.md` file to gather all the filters
+// each filter starts with `# filter_name`
+export class InputFilterMessageProvider extends HoverMessageProvider {
+  /**
+   * @param {string} functionsMd
+   */
+  constructor(functionsMd) {
+    super();
+    this.parseFilters(functionsMd);
+  }
+
+  /**
+   * parser a markdown documentation text to extract all the filters
+   * and their documentation
+   * @param {string} content
+   */
+  parseFilters(content) {
+    this.__filterDoc = {};
+    let body = [];
+    let fn = "";
+    for (let line of content.split("\n")) {
+      if (line.startsWith("#")) {
+        if (fn) {
+          this.__filterDoc[fn] = body.join("\n").trim();
+        }
+
+        fn = line.slice(2).trim();
+        body = [];
+      } else {
+        body.push(line);
+      }
+    }
+
+    if (fn && body.length) {
+      this.__filterDoc[fn] = body.join("\n").trim();
+    }
+  }
+
+  /**
+   * find a filter by its index in the token stream
+   * @param {int} index
+   * @param {import("chevrotain").[]} tokens
+   * @returns {string|null} the filter name or null if not found
+   */
+  findFilter(index, tokens) {
+    const token = tokens[index];
+
+    // Check if it's an Identifier token or has Identifier as a category/longer_alt
+    const isIdentifierLike =
+      token.tokenType.name === "Identifier" ||
+      (token.tokenType.LONGER_ALT &&
+        token.tokenType.LONGER_ALT.name === "Identifier") ||
+      (token.tokenType.CATEGORIES &&
+        token.tokenType.CATEGORIES.some((cat) => cat.name === "Identifier"));
+
+    if (!isIdentifierLike) {
+      return null;
+    }
+
+    const name = token.image;
+    if (this.__filterDoc[name]) {
+      return name;
+    }
+
+    return null;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  isMatch(index, tokens, parser) {
+    // Check if this looks like a filter (either after = or after |)
+    if (index === 0) {
+      return false;
+    }
+
+    const prevToken = tokens[index - 1];
+    const isAfterEquals = prevToken.image === "=";
+    const isAfterPipe = prevToken.image === "|";
+
+    if (!isAfterEquals && !isAfterPipe) {
+      return false;
+    }
+
+    // For input filters, we need to check if there's a "filters" token before the "=" token
+    if (isAfterEquals) {
+      // Look backwards to find "filters" token
+      for (let i = index - 2; i >= 0; i--) {
+        const token = tokens[i];
+        if (token.image === "filters") {
+          // Found "filters" token, this is likely an input filter context
+          return !!this.findFilter(index, tokens);
+        }
+        // Stop looking if we hit certain boundary tokens
+        if (
+          token.image === "{" ||
+          token.image === "}" ||
+          token.image === "\n"
+        ) {
+          break;
+        }
+      }
+      return false;
+    }
+
+    // For pipe filters, check if we're in an input filter chain (filters=something|this_token)
+    if (isAfterPipe) {
+      // Look backwards to find if there's a "filters=" pattern
+      for (let i = index - 2; i >= 0; i--) {
+        const token = tokens[i];
+        if (token.image === "=" && i > 0 && tokens[i - 1].image === "filters") {
+          // Found "filters=" pattern, this is an input filter context
+          return !!this.findFilter(index, tokens);
+        }
+        // Stop looking if we hit certain boundary tokens that would indicate we're outside the filter chain
+        // Don't stop at intermediate pipes - they're part of the filter chain
+        if (
+          token.image === "{" ||
+          token.image === "}" ||
+          token.image === "\n"
+        ) {
+          break;
+        }
+      }
+      return false;
+    }
+
+    return false;
+  }
+
+  render(index, tokens) {
+    const fn = this.findFilter(index, tokens);
+
+    if (fn) {
+      return this.__filterDoc[fn];
+    }
+
+    return undefined;
+  }
+}