@xano/xanoscript-language-server 11.0.3

package/onHover/InputFilterMessageProvider.spec.js

@@ -0,0 +1,329 @@
+import { expect } from "chai";
+import { beforeEach, describe, it } from "mocha";
+import { InputFilterMessageProvider } from "./InputFilterMessageProvider.js";
+
+const testInputFiltersMd = `
+# trim
+Removes excess whitespace from the beginning and end of the entry.
+
+# min
+Enforces a minimum value or length for the entry.
+
+# max
+Enforces a maximum value or length for the entry.
+
+# lower
+Converts all characters to lowercase.
+
+# upper
+Converts all characters to uppercase.
+`;
+
+describe("InputFilterMessageProvider", () => {
+  let provider;
+
+  beforeEach(() => {
+    provider = new InputFilterMessageProvider(testInputFiltersMd);
+  });
+
+  describe("parseFilters", () => {
+    it("should parse filter documentation correctly", () => {
+      expect(provider.__filterDoc["trim"]).to.equal(
+        "Removes excess whitespace from the beginning and end of the entry."
+      );
+      expect(provider.__filterDoc["min"]).to.equal(
+        "Enforces a minimum value or length for the entry."
+      );
+      expect(provider.__filterDoc["max"]).to.equal(
+        "Enforces a maximum value or length for the entry."
+      );
+      expect(provider.__filterDoc["lower"]).to.equal(
+        "Converts all characters to lowercase."
+      );
+    });
+
+    it("should have all expected filters", () => {
+      const filterNames = Object.keys(provider.__filterDoc);
+      expect(filterNames).to.include.members([
+        "trim",
+        "min",
+        "max",
+        "lower",
+        "upper",
+      ]);
+    });
+  });
+
+  describe("findFilter", () => {
+    it("should find existing filters", () => {
+      const mockTokens = [{ tokenType: { name: "Identifier" }, image: "trim" }];
+
+      const result = provider.findFilter(0, mockTokens);
+      expect(result).to.equal("trim");
+    });
+
+    it("should return null for non-existent filters", () => {
+      const mockTokens = [
+        { tokenType: { name: "Identifier" }, image: "nonexistent" },
+      ];
+
+      const result = provider.findFilter(0, mockTokens);
+      expect(result).to.be.null;
+    });
+
+    it("should return null for non-identifier tokens", () => {
+      const mockTokens = [
+        { tokenType: { name: "StringLiteral" }, image: "trim" },
+      ];
+
+      const result = provider.findFilter(0, mockTokens);
+      expect(result).to.be.null;
+    });
+  });
+
+  describe("isMatch", () => {
+    it("should return false for index 0", () => {
+      const tokens = [{ image: "trim" }];
+      expect(provider.isMatch(0, tokens)).to.be.false;
+    });
+
+    it("should return false when not after = or |", () => {
+      const tokens = [{ image: "something" }, { image: "trim" }];
+      expect(provider.isMatch(1, tokens)).to.be.false;
+    });
+
+    it("should return true for filter after filters=", () => {
+      const tokens = [
+        { image: "filters" },
+        { image: "=" },
+        { tokenType: { name: "Identifier" }, image: "trim" },
+      ];
+      expect(provider.isMatch(2, tokens)).to.be.true;
+    });
+
+    it("should return true for filter after pipe in filters context", () => {
+      const tokens = [
+        { image: "filters" },
+        { image: "=" },
+        { tokenType: { name: "Identifier" }, image: "trim" },
+        { image: "|" },
+        { tokenType: { name: "Identifier" }, image: "upper" },
+      ];
+      expect(provider.isMatch(4, tokens)).to.be.true;
+    });
+
+    it("should return false for filter after = without filters", () => {
+      const tokens = [
+        { image: "value" },
+        { image: "=" },
+        { tokenType: { name: "Identifier" }, image: "trim" },
+      ];
+      expect(provider.isMatch(2, tokens)).to.be.false;
+    });
+
+    it("should return false for unknown filter", () => {
+      const tokens = [
+        { image: "filters" },
+        { image: "=" },
+        { tokenType: { name: "Identifier" }, image: "unknown_filter" },
+      ];
+      expect(provider.isMatch(2, tokens)).to.be.false;
+    });
+
+    it("should stop searching at boundary tokens", () => {
+      const tokens = [
+        { image: "filters" },
+        { image: "=" },
+        { image: "something" },
+        { image: "{" },
+        { image: "other" },
+        { image: "=" },
+        { tokenType: { name: "Identifier" }, image: "trim" },
+      ];
+      expect(provider.isMatch(6, tokens)).to.be.false;
+    });
+
+    it("should handle complex filter chain", () => {
+      const tokens = [
+        { image: "text" },
+        { image: "name" },
+        { image: "filters" },
+        { image: "=" },
+        {
+          tokenType: { name: "trim token", LONGER_ALT: { name: "Identifier" } },
+          image: "trim",
+        },
+        { image: "|" },
+        { tokenType: { name: "Identifier" }, image: "upper" },
+        { image: "|" },
+        { tokenType: { name: "Identifier" }, image: "lower" },
+      ];
+      expect(provider.isMatch(4, tokens)).to.be.true; // trim
+      expect(provider.isMatch(6, tokens)).to.be.true; // upper
+      expect(provider.isMatch(8, tokens)).to.be.true; // lower
+    });
+  });
+
+  describe("render", () => {
+    it("should return filter documentation when filter exists", () => {
+      const mockTokens = [{ tokenType: { name: "Identifier" }, image: "trim" }];
+
+      const result = provider.render(0, mockTokens);
+      expect(result).to.equal(
+        "Removes excess whitespace from the beginning and end of the entry."
+      );
+    });
+
+    it("should return undefined when filter doesn't exist", () => {
+      const mockTokens = [
+        { tokenType: { name: "Identifier" }, image: "nonexistent" },
+      ];
+
+      const result = provider.render(0, mockTokens);
+      expect(result).to.be.undefined;
+    });
+  });
+
+  describe("integration with real parser", () => {
+    it("should work with actual XanoScript parsing", async () => {
+      // Import the actual parser functions
+      const { lexDocument } = await import("../lexer/lexer.js");
+      const { xanoscriptParser } = await import("../parser/parser.js");
+      const { getSchemeFromContent } = await import("../utils.js");
+
+      const code = `table users {
+  text name filters=trim
+  email address filters=lower|trim
+}`;
+
+      // Get the proper scheme
+      const scheme = getSchemeFromContent(code);
+      // console.log("Detected scheme:", scheme);
+
+      // Tokenize the document
+      const lexResult = lexDocument(code);
+      expect(lexResult.errors).to.have.length(0);
+
+      // Parse the XanoScript with the correct scheme
+      const parser = xanoscriptParser(code, scheme);
+      const tokens = lexResult.tokens;
+
+      // Find the token for "trim" after filters=
+      let trimTokenIndex = -1;
+      for (let i = 0; i < tokens.length; i++) {
+        if (
+          tokens[i].image === "trim" &&
+          i > 0 &&
+          tokens[i - 1].image === "="
+        ) {
+          trimTokenIndex = i;
+          break;
+        }
+      }
+
+      expect(trimTokenIndex).to.be.greaterThan(-1);
+
+      // Test that the provider matches
+      // console.log("Parser sectionStack:", parser.sectionStack);
+      // console.log(
+      //   "Token at index",
+      //   trimTokenIndex,
+      //   ":",
+      //   tokens[trimTokenIndex]
+      // );
+      // console.log("Previous token:", tokens[trimTokenIndex - 1]);
+
+      const matches = provider.isMatch(trimTokenIndex, tokens, parser);
+      // console.log("Provider matches:", matches);
+
+      expect(matches).to.be.true;
+
+      // Test that it renders the correct documentation
+      const result = provider.render(trimTokenIndex, tokens, parser);
+      expect(result).to.equal(
+        "Removes excess whitespace from the beginning and end of the entry."
+      );
+    });
+
+    it("should NOT match filters in pipe expressions", async () => {
+      // Import the actual parser functions
+      const { lexDocument } = await import("../lexer/lexer.js");
+      const { xanoscriptParser } = await import("../parser/parser.js");
+
+      const code = `query test verb=GET {
+  stack {
+    var $result { value = $input.name|trim }
+  }
+}`;
+
+      // Tokenize the document
+      const lexResult = lexDocument(code);
+      expect(lexResult.errors).to.have.length(0);
+
+      // Parse the XanoScript to ensure no syntax errors
+      xanoscriptParser("query", code);
+      const tokens = lexResult.tokens;
+
+      // Find the token for "trim" after |
+      let trimTokenIndex = -1;
+      for (let i = 0; i < tokens.length; i++) {
+        if (
+          tokens[i].image === "trim" &&
+          i > 0 &&
+          tokens[i - 1].image === "|"
+        ) {
+          trimTokenIndex = i;
+          break;
+        }
+      }
+
+      expect(trimTokenIndex).to.be.greaterThan(-1);
+
+      // Test that the InputFilterMessageProvider does NOT match pipe expressions without filters= context
+      const matches = provider.isMatch(trimTokenIndex, tokens);
+      expect(matches).to.be.false;
+    });
+
+    it("should work with actual XanoScript parsing for input filters", async () => {
+      // Import the actual parser functions
+      const { lexDocument } = await import("../lexer/lexer.js");
+      const { xanoscriptParser } = await import("../parser/parser.js");
+
+      const code = `table users {
+  text name filters=trim|upper
+}`;
+
+      // Tokenize the document
+      const lexResult = lexDocument(code);
+      expect(lexResult.errors).to.have.length(0);
+
+      // Parse the XanoScript to ensure no syntax errors
+      xanoscriptParser("table", code);
+      const tokens = lexResult.tokens;
+
+      // Find the token for "trim" after filters=
+      let trimTokenIndex = -1;
+      for (let i = 0; i < tokens.length; i++) {
+        if (
+          tokens[i].image === "trim" &&
+          i > 0 &&
+          tokens[i - 1].image === "="
+        ) {
+          trimTokenIndex = i;
+          break;
+        }
+      }
+
+      expect(trimTokenIndex).to.be.greaterThan(-1);
+
+      // Test that the InputFilterMessageProvider matches input filters
+      const matches = provider.isMatch(trimTokenIndex, tokens);
+      expect(matches).to.be.true;
+
+      // Test the render method
+      const result = provider.render(trimTokenIndex, tokens);
+      expect(result).to.not.be.undefined;
+      expect(result).to.include("whitespace");
+    });
+  });
+});

package/onHover/InputVariableMessageProvider.js

@@ -0,0 +1,55 @@
+import { HoverMessageProvider } from "./HoverMessageProvider.js";
+
+export class InputVariableMessageProvider extends HoverMessageProvider {
+  constructor() {
+    super();
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  isMatch(index, tokens, parser) {
+    const token = tokens[index];
+
+    return (
+      index > 2 &&
+      tokens[index - 2].image === "$input" &&
+      tokens[index - 1].image === "." &&
+      token.tokenType.name === "Identifier"
+    );
+  }
+
+  renderUndefined(inputName) {
+    return [
+      "**Error**: This input is not defined.",
+      "Add a definition for it in your `input` clause.",
+      "```xs",
+      "input {",
+      "  text? " + inputName,
+      "}",
+      "```",
+    ].join("\n");
+  }
+
+  render(index, tokens, parser) {
+    const inputName = tokens[index].image;
+    const inputInfo = parser.__symbolTable.input[inputName];
+
+    if (!inputInfo) {
+      return this.renderUndefined(inputName);
+    } else {
+      const type = inputInfo.iterable
+        ? `[${inputInfo.type},...]`
+        : `${inputInfo.type}`;
+
+      const contents = [`input **${inputName}** of type \`${type}\` `];
+
+      if (inputInfo.nullable) {
+        contents.push(`- ${inputName} is _nullable_ (\`${inputInfo.type}?\`)`);
+      }
+
+      if (inputInfo.optional) {
+        contents.push(`- ${inputName} is _optional_ (\`${inputName}?\`)`);
+      }
+      return contents.join("\n\n");
+    }
+  }
+}

package/onHover/QueryFilterMessageProvider.spec.js

@@ -0,0 +1,164 @@
+import { expect } from "chai";
+import { beforeEach, describe, it } from "mocha";
+import { lexDocument } from "../lexer/lexer.js";
+import { QueryFilterMessageProvider } from "./queryFilterMessageProvider.js";
+
+const testQueryFiltersMd = `
+# inner_product
+Provides the inner product between two vectors.
+
+\`\`\`xs
+db.embedding.vector|inner_product:$input.query_vector
+\`\`\`
+
+Calculates the dot product between two numeric arrays.
+
+# cosine_distance
+Provides the cosine distance between two vectors.
+
+\`\`\`xs
+db.embedding.vector|cosine_distance:$input.query_vector
+\`\`\`
+
+Calculates the cosine distance (1 - cosine similarity) between two numeric arrays.
+
+# distance
+Provides the distance in meters between two geometries.
+
+\`\`\`xs
+db.location.geometry|distance:$input.target_geometry
+\`\`\`
+
+Returns the distance between two geometric objects in meters.
+`;
+
+describe("QueryFilterMessageProvider", () => {
+  let provider;
+
+  beforeEach(() => {
+    provider = new QueryFilterMessageProvider(testQueryFiltersMd);
+  });
+
+  describe("parseFilters", () => {
+    it("should parse filter documentation correctly", () => {
+      expect(provider.__filterDoc["inner_product"]).to.equal(
+        "Provides the inner product between two vectors.\n\n```xs\ndb.embedding.vector|inner_product:$input.query_vector\n```\n\nCalculates the dot product between two numeric arrays."
+      );
+      expect(provider.__filterDoc["cosine_distance"]).to.equal(
+        "Provides the cosine distance between two vectors.\n\n```xs\ndb.embedding.vector|cosine_distance:$input.query_vector\n```\n\nCalculates the cosine distance (1 - cosine similarity) between two numeric arrays."
+      );
+    });
+
+    it("should have all expected filters", () => {
+      const filterNames = Object.keys(provider.__filterDoc);
+      expect(filterNames).to.include.members([
+        "inner_product",
+        "cosine_distance",
+        "distance",
+      ]);
+    });
+  });
+
+  describe("findFilter", () => {
+    it("should find existing filters", () => {
+      const tokens = lexDocument("inner_product").tokens;
+      const result = provider.findFilter(0, tokens);
+      expect(result).to.equal("inner_product");
+    });
+
+    it("should return null for non-existent filters", () => {
+      const tokens = lexDocument("nonexistent_filter").tokens;
+      const result = provider.findFilter(0, tokens);
+      expect(result).to.be.null;
+    });
+
+    it("should return null for non-identifier tokens", () => {
+      const tokens = lexDocument("=").tokens;
+      const result = provider.findFilter(0, tokens);
+      expect(result).to.be.null;
+    });
+  });
+
+  describe("isMatch", () => {
+    it("should match filters in search context after pipe", () => {
+      const code =
+        "query books { where = $db.embedding.vector|inner_product:$input.query_vector }";
+      const tokens = lexDocument(code).tokens;
+
+      // Find the index of 'inner_product' token
+      const innerProductIndex = tokens.findIndex(
+        (token) => token.image === "inner_product"
+      );
+      expect(innerProductIndex).to.be.greaterThan(-1);
+
+      const result = provider.isMatch(innerProductIndex, tokens);
+      expect(result).to.be.true;
+    });
+
+    it("should not match filters outside search context", () => {
+      const code =
+        "query books { stack { var $result { value = inner_product } } }";
+      const tokens = lexDocument(code).tokens;
+
+      // Find the index of 'inner_product' token
+      const innerProductIndex = tokens.findIndex(
+        (token) => token.image === "inner_product"
+      );
+      expect(innerProductIndex).to.be.greaterThan(-1);
+
+      const result = provider.isMatch(innerProductIndex, tokens);
+      expect(result).to.be.false;
+    });
+
+    it("should not match when there's no pipe before the token", () => {
+      const code = "query books { where = $db.embedding.vector inner_product }";
+      const tokens = lexDocument(code).tokens;
+
+      // Find the index of 'inner_product' token
+      const innerProductIndex = tokens.findIndex(
+        (token) => token.image === "inner_product"
+      );
+      expect(innerProductIndex).to.be.greaterThan(-1);
+
+      const result = provider.isMatch(innerProductIndex, tokens);
+      expect(result).to.be.false;
+    });
+
+    it("should not match at index 0", () => {
+      const tokens = lexDocument("inner_product").tokens;
+      const result = provider.isMatch(0, tokens);
+      expect(result).to.be.false;
+    });
+
+    it("should handle complex search expressions", () => {
+      const code =
+        "query books { where = $db.embedding.vector|cosine_distance:$input.query_vector } as $matched_books";
+      const tokens = lexDocument(code).tokens;
+
+      // Find the index of 'cosine_distance' token
+      const cosineDistanceIndex = tokens.findIndex(
+        (token) => token.image === "cosine_distance"
+      );
+      expect(cosineDistanceIndex).to.be.greaterThan(-1);
+
+      const result = provider.isMatch(cosineDistanceIndex, tokens);
+      expect(result).to.be.true;
+    });
+  });
+
+  describe("render", () => {
+    it("should render documentation for existing filters", () => {
+      const tokens = lexDocument("inner_product").tokens;
+      const result = provider.render(0, tokens);
+      expect(result).to.include(
+        "Provides the inner product between two vectors"
+      );
+    });
+
+    it("should return undefined for non-matching tokens", () => {
+      const tokens = lexDocument("nonexistent_filter").tokens;
+      const result = provider.render(0, tokens);
+      expect(result).to.be.undefined;
+    });
+  });
+});