@xano/xanoscript-language-server 11.0.3

package/onCompletion/contentAssist.js

@@ -0,0 +1,183 @@
+import { PipeToken } from "../lexer/control.js";
+import { lexDocument } from "../lexer/lexer.js";
+import { mapTokenToType } from "../lexer/tokens.js";
+import { FilterMessageProvider } from "../onHover/FilterMessageProvider.js";
+import { encodeTokenType } from "../onSemanticCheck/tokens.js";
+import { filterNames } from "../parser/generic/filterNames.js";
+import { parser } from "../parser/parser.js";
+
+// FIXME: this should be imported from the onHover/FilterMessageProvider.js
+const filterDocsMarkdown = `
+# upper
+Convert text to uppercase
+
+# lower
+Convert text to lowercase
+
+# trim
+Remove whitespace from the beginning and end of a string
+
+# count
+Get the number of elements in an array or characters in a string
+
+# first
+Get the first element of an array
+
+# last
+Get the last element of an array
+
+# reverse
+Reverse the order of elements in an array
+
+# sin
+Calculate the sine of a number (in radians)
+
+# cos
+Calculate the cosine of a number (in radians)
+
+# floor
+Round a number down to the nearest integer
+
+# ceil
+Round a number up to the nearest integer
+
+# round
+Round a number to the nearest integer
+
+# concat
+Concatenate strings together
+
+# length
+Get the length of a string or array
+
+# split
+Split a string into an array based on a delimiter
+
+# join
+Join array elements into a string with a separator
+
+# push
+Add an element to the end of an array
+
+# pop
+Remove and return the last element from an array
+
+# unique
+Remove duplicate values from an array
+
+# sort
+Sort an array in ascending order
+
+# filter_empty
+Remove empty values from an array
+
+# flatten
+Flatten a nested array structure
+
+# merge
+Merge two arrays together
+
+# abs
+Get the absolute value of a number
+
+# max
+Get the maximum value from an array of numbers
+
+# min
+Get the minimum value from an array of numbers
+
+# sum
+Calculate the sum of numbers in an array
+
+# avg
+Calculate the average of numbers in an array
+`;
+
+// Create a filter message provider instance to access filter documentation
+const filterMessageProvider = new FilterMessageProvider(filterDocsMarkdown);
+
+export function suggestable(suggestion) {
+  // token without label are not suggested for auto-completion
+  return !!suggestion.nextTokenType.LABEL;
+}
+
+function isAfterPipeToken(tokens) {
+  if (tokens.length === 0) return false;
+
+  // Check if the last token is a pipe token
+  const lastToken = tokens[tokens.length - 1];
+  return lastToken.tokenType === PipeToken;
+}
+
+function createFilterSuggestions() {
+  return filterNames.map((filterName) => {
+    const documentation = filterMessageProvider.__filterDoc[filterName];
+
+    return {
+      label: filterName,
+      kind: encodeTokenType("function"), // Filters are function-like
+      documentation: documentation
+        ? {
+            kind: "markdown",
+            value: documentation,
+          }
+        : undefined,
+    };
+  });
+}
+
+export function getContentAssistSuggestions(text, scheme) {
+  try {
+    const lexResult = lexDocument(text);
+
+    const partialTokenVector = lexResult.tokens;
+
+    // Check if we're after a pipe token - if so, suggest filters
+    if (isAfterPipeToken(partialTokenVector)) {
+      return createFilterSuggestions();
+    }
+
+    let syntacticSuggestions;
+    parser.reset();
+    if (scheme === "db") {
+      syntacticSuggestions = parser.computeContentAssist(
+        "tableDeclaration",
+        partialTokenVector
+      );
+    } else if (scheme === "api") {
+      syntacticSuggestions = parser.computeContentAssist(
+        "queryDeclaration",
+        partialTokenVector
+      );
+    } else if (scheme === "function") {
+      syntacticSuggestions = parser.computeContentAssist(
+        "functionDeclaration",
+        partialTokenVector
+      );
+    } else if (scheme === "task") {
+      syntacticSuggestions = parser.computeContentAssist(
+        "taskDeclaration",
+        partialTokenVector
+      );
+    } else {
+      return [];
+    }
+
+    // The suggestions also include the context, we are only interested
+    // in the TokenTypes in this example.
+    const tokenTypesSuggestions = syntacticSuggestions
+      .filter(suggestable)
+      .map((suggestion) => {
+        const tokenType = mapTokenToType(suggestion.nextTokenType.name);
+        return {
+          label: suggestion.nextTokenType.LABEL,
+          kind: encodeTokenType(tokenType),
+        };
+      });
+
+    return tokenTypesSuggestions;
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+}

package/onCompletion/contentAssist.spec.js

@@ -0,0 +1,275 @@
+import { expect } from "chai";
+import { describe, it, xit } from "mocha";
+import { getContentAssistSuggestions, suggestable } from "./contentAssist.js";
+
+describe("contentAssist", () => {
+  describe("suggestable", () => {
+    it("should return true for suggestions with LABEL", () => {
+      const suggestion = {
+        nextTokenType: {
+          LABEL: "test_label",
+        },
+      };
+      expect(suggestable(suggestion)).to.be.true;
+    });
+
+    it("should return false for suggestions without LABEL", () => {
+      const suggestion = {
+        nextTokenType: {
+          name: "TestToken",
+        },
+      };
+      expect(suggestable(suggestion)).to.be.false;
+    });
+
+    it("should return false for suggestions with empty LABEL", () => {
+      const suggestion = {
+        nextTokenType: {
+          LABEL: "",
+        },
+      };
+      expect(suggestable(suggestion)).to.be.false;
+    });
+  });
+
+  describe("getContentAssistSuggestions", () => {
+    xit("should return suggestions for each parser scheme with minimal valid input", () => {
+      const schemes = ["function", "api", "db", "task"];
+      const minimalInputs = {
+        function: "function test { input {\n} \nstack {\ndb.",
+        api: "query test { input { text name } stack { } \nresponse = null }",
+        db: "table test { columns { id int } }",
+        task: "task test { input { } stack { } }",
+      };
+      schemes.forEach((scheme) => {
+        const text = minimalInputs[scheme];
+        const suggestions = getContentAssistSuggestions(text, scheme);
+        console.log(`Scheme: ${scheme}, Suggestions:`, suggestions);
+        expect(suggestions).to.be.an("array");
+        expect(suggestions.length).to.be.greaterThan(0);
+        // Should contain at least one suggestion with a label
+        expect(suggestions.some((s) => s.label)).to.be.true;
+      });
+    });
+    describe("filter suggestions after pipe token", () => {
+      it("should suggest filters when text ends with pipe token", () => {
+        const text = "$variable|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions).to.be.an("array");
+        expect(suggestions.length).to.be.greaterThan(0);
+
+        // Check that we get filter suggestions
+        const filterLabels = suggestions.map((s) => s.label);
+        expect(filterLabels).to.include("to_upper");
+        expect(filterLabels).to.include("to_lower");
+        expect(filterLabels).to.include("trim");
+        expect(filterLabels).to.include("count");
+      });
+
+      it("should suggest filters with correct completion kind", () => {
+        const text = "$var|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions.length).to.be.greaterThan(0);
+
+        // All suggestions should have a kind property (encoded as number)
+        suggestions.forEach((suggestion) => {
+          expect(suggestion).to.have.property("kind");
+          expect(suggestion.kind).to.be.a("number");
+        });
+      });
+
+      it("should suggest filters for complex expressions ending with pipe", () => {
+        const text = "$input.name|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions).to.be.an("array");
+        expect(suggestions.length).to.be.greaterThan(0);
+
+        const filterLabels = suggestions.map((s) => s.label);
+        expect(filterLabels).to.include("to_upper");
+      });
+
+      it("should include math filters in suggestions", () => {
+        const text = "$number|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        const filterLabels = suggestions.map((s) => s.label);
+        expect(filterLabels).to.include("sin");
+        expect(filterLabels).to.include("cos");
+        expect(filterLabels).to.include("floor");
+        expect(filterLabels).to.include("ceil");
+      });
+
+      it("should include array filters in suggestions", () => {
+        const text = "$array|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        const filterLabels = suggestions.map((s) => s.label);
+        expect(filterLabels).to.include("first");
+        expect(filterLabels).to.include("last");
+        expect(filterLabels).to.include("count");
+        expect(filterLabels).to.include("reverse");
+      });
+
+      it("should work with different schemes when pipe is present", () => {
+        const text = "$var|";
+
+        const apiSuggestions = getContentAssistSuggestions(text, "api");
+        const dbSuggestions = getContentAssistSuggestions(text, "db");
+        const functionSuggestions = getContentAssistSuggestions(
+          text,
+          "function"
+        );
+        const taskSuggestions = getContentAssistSuggestions(text, "task");
+
+        // All should return filter suggestions since pipe is detected first
+        expect(apiSuggestions.length).to.be.greaterThan(0);
+        expect(dbSuggestions.length).to.be.greaterThan(0);
+        expect(functionSuggestions.length).to.be.greaterThan(0);
+        expect(taskSuggestions.length).to.be.greaterThan(0);
+
+        // They should all be the same (filter suggestions)
+        expect(apiSuggestions.length).to.equal(dbSuggestions.length);
+        expect(apiSuggestions.length).to.equal(functionSuggestions.length);
+        expect(apiSuggestions.length).to.equal(taskSuggestions.length);
+      });
+
+      it("should include documentation for filters when available", () => {
+        const text = "$var|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions.length).to.be.greaterThan(0);
+
+        // Find a filter that should have documentation
+        const upperFilter = suggestions.find((s) => s.label === "upper");
+        const trimFilter = suggestions.find((s) => s.label === "trim");
+
+        // Check that some filters have documentation
+        if (upperFilter) {
+          expect(upperFilter).to.have.property("documentation");
+          if (upperFilter.documentation) {
+            expect(upperFilter.documentation).to.have.property(
+              "kind",
+              "markdown"
+            );
+            expect(upperFilter.documentation).to.have.property("value");
+            expect(upperFilter.documentation.value).to.be.a("string");
+          }
+        }
+
+        if (trimFilter) {
+          expect(trimFilter).to.have.property("documentation");
+          if (trimFilter.documentation) {
+            expect(trimFilter.documentation).to.have.property(
+              "kind",
+              "markdown"
+            );
+            expect(trimFilter.documentation).to.have.property("value");
+            expect(trimFilter.documentation.value).to.be.a("string");
+          }
+        }
+      });
+    });
+
+    describe("normal completion without pipe token", () => {
+      it("should return empty array for unknown scheme", () => {
+        const text = "query test { ";
+        const suggestions = getContentAssistSuggestions(text, "unknown");
+
+        expect(suggestions).to.be.an("array");
+        expect(suggestions.length).to.equal(0);
+      });
+
+      it("should handle empty text", () => {
+        const text = "";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions).to.be.an("array");
+        // Should not crash and return some form of suggestions or empty array
+      });
+
+      it("should not suggest filters when no pipe token present", () => {
+        const text = "query test { stack { var $test { value = ";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        // Should not return filter suggestions (those would have 270+ items)
+        // Normal syntactic suggestions should be much fewer
+        if (suggestions.length > 200) {
+          // If we get a lot of suggestions, they shouldn't be filters
+          const filterLabels = suggestions.map((s) => s.label);
+          expect(filterLabels).to.not.include("upper");
+          expect(filterLabels).to.not.include("lower");
+        }
+      });
+
+      it("should handle malformed syntax gracefully", () => {
+        const text = "query { { { invalid syntax";
+
+        // Should not throw an error
+        expect(() => {
+          getContentAssistSuggestions(text, "api");
+        }).to.not.throw();
+      });
+    });
+
+    describe("edge cases", () => {
+      it("should handle text with only pipe token", () => {
+        const text = "|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions).to.be.an("array");
+        expect(suggestions.length).to.be.greaterThan(0);
+
+        // Should still suggest filters
+        const filterLabels = suggestions.map((s) => s.label);
+        expect(filterLabels).to.include("to_upper");
+      });
+
+      it("should handle multiple pipe tokens", () => {
+        const text = "$var|to_upper|";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions).to.be.an("array");
+        expect(suggestions.length).to.be.greaterThan(0);
+
+        // Should suggest filters for the last pipe
+        const filterLabels = suggestions.map((s) => s.label);
+        expect(filterLabels).to.include("to_lower");
+      });
+
+      it("should handle whitespace around pipe", () => {
+        const text = "$var | ";
+        const suggestions = getContentAssistSuggestions(text, "api");
+
+        expect(suggestions).to.be.an("array");
+        // Should handle this case gracefully, even if no suggestions
+      });
+    });
+
+    describe("error handling", () => {
+      it("should handle invalid input gracefully", () => {
+        // Test with text that might cause issues but should not throw
+        const edgeCases = [
+          "", // empty string should work
+          " ", // whitespace
+          "invalid_syntax_here",
+        ];
+
+        edgeCases.forEach((text) => {
+          expect(() => {
+            const result = getContentAssistSuggestions(text, "api");
+            expect(result).to.be.an("array");
+          }).to.not.throw();
+        });
+      });
+
+      it("should return empty array on lexer errors", () => {
+        // Test with text that causes lexer issues - should catch and return []
+        const result = getContentAssistSuggestions("query { invalid }", "api");
+        expect(result).to.be.an("array");
+      });
+    });
+  });
+});

package/onCompletion/onCompletion.js

@@ -0,0 +1,38 @@
+import { mapToVirtualJS } from "../embedded/embeddedContent.js";
+import { getSchemeFromContent } from "../utils.js";
+import { getContentAssistSuggestions } from "./contentAssist.js";
+
+/**
+ *
+ * @param {import('vscode-languageserver-protocol').CompletionParams} params
+ * @param {import('vscode-languageserver').TextDocuments} documents
+ * @returns
+ */
+export function onCompletion(params, documents) {
+  const document = documents.get(params.textDocument.uri);
+
+  if (!document) {
+    console.error(
+      "onCompletion(): Document not found for URI:",
+      params.textDocument.uri
+    );
+    return null;
+  }
+
+  const position = params.position;
+  const text = document.getText();
+  const offset = document.offsetAt(position);
+
+  // Check if we're in an embedded JavaScript region
+  const virtualPos = mapToVirtualJS(offset, text);
+  if (virtualPos) {
+    // We're in embedded JS - return null to let VS Code's JS service handle it
+    // The virtual document provider will expose the JS content
+    return null;
+  }
+
+  // Otherwise, handle as regular XanoScript
+  const scheme = getSchemeFromContent(text);
+
+  return getContentAssistSuggestions(text.slice(0, offset), scheme);
+}

package/onDidChangeContent/onDidChangeContent.js

@@ -0,0 +1,128 @@
+import { xanoscriptParser } from "../parser/parser";
+import { getSchemeFromContent } from "../utils";
+
+/**
+ *
+ * @param {import('vscode-languageserver-protocol').TextDocumentChangeEvent} params
+ * @param {import('vscode-languageserver').Connection} connection
+ * @returns
+ */
+export function onDidChangeContent(params, connection) {
+  const document = params.document;
+
+  if (!document) {
+    console.error(
+      "onDidChangeContent(): Document not found for URI:",
+      params.textDocument.uri
+    );
+    return null;
+  }
+
+  const text = document.getText();
+
+  const scheme = getSchemeFromContent(text);
+
+  try {
+    // Parse the XanoScript file
+    const parser = xanoscriptParser(text, scheme);
+
+    if (parser.errors.length > 0) {
+      // If parsing succeeds, send an empty diagnostics array (no errors)
+      connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
+    }
+
+    for (const error of parser.errors) {
+      console.error(
+        `onDidChangeContent(): Error parsing document: ${error.name}`
+      );
+    }
+
+    // If parsing fails, create a diagnostic (error message) to display in VS Code
+    const errors = parser.errors.map((error) => {
+      return {
+        severity: 1,
+        range: error.token
+          ? {
+              start: document.positionAt(error.token.startOffset),
+              end: document.positionAt(error.token.endOffset + 1),
+            }
+          : {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 1 },
+            },
+        message: error.message,
+      };
+    });
+
+    const warnings = parser.warnings.map((warning) => {
+      return {
+        severity: 2,
+        range: warning.token
+          ? {
+              start: document.positionAt(warning.token.startOffset),
+              end: document.positionAt(warning.token.endOffset + 1),
+            }
+          : {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 1 },
+            },
+        message: warning.message,
+      };
+    });
+
+    const informations = parser.informations.map((info) => {
+      return {
+        severity: 3,
+        range: info.token
+          ? {
+              start: document.positionAt(info.token.startOffset),
+              end: document.positionAt(info.token.endOffset + 1),
+            }
+          : {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 1 },
+            },
+        message: info.message,
+      };
+    });
+
+    const hints = parser.hints.map((hint) => {
+      return {
+        severity: 4,
+        range: hint.token
+          ? {
+              start: document.positionAt(hint.token.startOffset),
+              end: document.positionAt(hint.token.endOffset + 1),
+            }
+          : {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 1 },
+            },
+        message: hint.message,
+      };
+    });
+
+    console.log(
+      `onDidChangeContent(): sending diagnostic (${parser.errors.length} errors) for scheme:`,
+      scheme
+    );
+
+    connection.sendDiagnostics({
+      uri: document.uri,
+      diagnostics: [...errors, ...warnings, ...informations, ...hints],
+    });
+  } catch (error) {
+    // If parsing fails, create a diagnostic (error message) to display in VS Code
+    const diagnostics = [
+      {
+        severity: 1, // Error severity
+        range: {
+          start: { line: 0, character: 0 }, // Adjust range based on error details if available
+          end: { line: 0, character: 1 },
+        },
+        message: error.message || "Syntax error in XanoScript code",
+      },
+    ];
+    connection.sendDiagnostics({ uri: document.uri, diagnostics });
+  }
+}