@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/lexer/tests/table/table_lexer.spec.js

@@ -1,324 +0,0 @@
-import { expect } from "chai";
-import { tokenMatcher } from "chevrotain";
-import { readFileSync } from "fs";
-import { describe, it } from "mocha";
-import { Iterator } from "../../../utils.js";
-import { IntToken, TimestampToken } from "../../columns.js";
-import {
-  ColonToken,
-  CommaToken,
-  EqualToken,
-  LCurly,
-  LSquare,
-  Question,
-  RCurly,
-  RSquare,
-} from "../../control.js";
-import { SchemaToken } from "../../db.js";
-import { lexDocument } from "../../lexer.js";
-import { StringLiteral } from "../../literal.js";
-import { SecurityToken } from "../../security.js";
-import { TableToken } from "../../table.js";
-import {
-  AuthToken,
-  FalseToken,
-  FieldToken,
-  GuidToken,
-  Identifier,
-  IndexToken,
-  NewlineToken,
-  NowToken,
-  TrueToken,
-  TypeToken,
-} from "../../tokens.js";
-
-describe("Xanoscript Table Lexer", () => {
-  it("Can Lex an empty table", () => {
-    const empty_table = readFileSync(
-      "lexer/tests/table/empty_table.xs",
-      "utf8"
-    );
-    const lexingResult = lexDocument(empty_table);
-
-    expect(lexingResult.errors).to.be.empty;
-
-    const tokens = new Iterator(lexingResult.tokens);
-    expect(tokens.next().image).to.equal("table");
-    expect(tokens.next().image).to.equal("empty");
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("\n");
-    expect(tokens.next().image).to.equal("auth");
-    expect(tokens.next().image).to.equal("=");
-    expect(tokens.next().image).to.equal("false");
-    expect(tokens.next().image).to.equal("\n");
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next()).to.be.undefined;
-
-    tokens.reset();
-    // tokenMatcher acts as an "instanceof" check for Tokens
-    expect(tokenMatcher(tokens.next(), TableToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), AuthToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), EqualToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), FalseToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-  });
-
-  it("Can Lex a basic table", () => {
-    const basic_table = readFileSync(
-      "lexer/tests/table/basic_table.xs",
-      "utf8"
-    );
-    const lexingResult = lexDocument(basic_table);
-
-    expect(lexingResult.errors).to.be.empty;
-
-    const tokens = new Iterator(lexingResult.tokens);
-    expect(tokens.next().image).to.equal("table");
-    expect(tokens.next().image).to.equal("empty");
-    expect(tokens.next().image).to.equal("{");
-
-    // auth = true
-    expect(tokens.next().image).to.equal("\n");
-    expect(tokens.next().image).to.equal("auth");
-    expect(tokens.next().image).to.equal("=");
-    expect(tokens.next().image).to.equal("true");
-    expect(tokens.next().image).to.equal("\n");
-
-    // entering security section
-    expect(tokens.next().image).to.equal("security");
-    expect(tokens.next().image).to.equal("=");
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("\n");
-
-    // guid = "-iOFONN4cySSKJ0MTrPNojIWB5c"
-    expect(tokens.next().image).to.equal("guid");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"-iOFONN4cySSKJ0MTrPNojIWB5c"');
-    expect(tokens.next().image).to.equal("\n");
-
-    // leaving security section
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("\n");
-    expect(tokens.next().image).to.equal("\n");
-
-    // entering schema section
-    expect(tokens.next().image).to.equal("schema");
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("\n");
-
-    // int id
-    expect(tokens.next().image).to.equal("int");
-    expect(tokens.next().image).to.equal("id");
-    expect(tokens.next().image).to.equal("\n");
-
-    // timestamp created_at?=now
-    expect(tokens.next().image).to.equal("timestamp");
-    expect(tokens.next().image).to.equal("created_at");
-    expect(tokens.next().image).to.equal("?");
-    expect(tokens.next().image).to.equal("=");
-    expect(tokens.next().image).to.equal("now");
-    expect(tokens.next().image).to.equal("\n");
-
-    // leaving schema section
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("\n");
-    expect(tokens.next().image).to.equal("\n");
-
-    // entering index section
-    expect(tokens.next().image).to.equal("index");
-    expect(tokens.next().image).to.equal("=");
-    expect(tokens.next().image).to.equal("[");
-    expect(tokens.next().image).to.equal("\n");
-
-    // {type: "primary", field: [{name: "id"}]}
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("type");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"primary"');
-    expect(tokens.next().image).to.equal(",");
-    expect(tokens.next().image).to.equal("field");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal("[");
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("name");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"id"');
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("]");
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("\n");
-
-    // {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("type");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"gin"');
-    expect(tokens.next().image).to.equal(",");
-    expect(tokens.next().image).to.equal("field");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal("[");
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("name");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"xdo"');
-    expect(tokens.next().image).to.equal(",");
-    expect(tokens.next().image).to.equal("op");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"jsonb_path_op"');
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("]");
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("\n");
-
-    // {type: "btree", field: [{name: "created_at", op: "desc"}]}
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("type");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"btree"');
-    expect(tokens.next().image).to.equal(",");
-    expect(tokens.next().image).to.equal("field");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal("[");
-    expect(tokens.next().image).to.equal("{");
-    expect(tokens.next().image).to.equal("name");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"created_at"');
-    expect(tokens.next().image).to.equal(",");
-    expect(tokens.next().image).to.equal("op");
-    expect(tokens.next().image).to.equal(":");
-    expect(tokens.next().image).to.equal('"desc"');
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("]");
-    expect(tokens.next().image).to.equal("}");
-    expect(tokens.next().image).to.equal("\n");
-
-    // leaving index section
-    expect(tokens.next().image).to.equal("]");
-    expect(tokens.next().image).to.equal("\n");
-
-    // leaving table
-    expect(tokens.next().image).to.equal("}");
-
-    tokens.reset();
-    // // tokenMatcher acts as an "instanceof" check for Tokens
-    expect(tokenMatcher(tokens.next(), TableToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), AuthToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), EqualToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), TrueToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    // security {
-    //   guid = "-iOFONN4cySSKJ0MTrPNojIWB5c"
-    // }
-    expect(tokenMatcher(tokens.next(), SecurityToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), EqualToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), GuidToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    // schema {
-    //   int id
-    //   timestamp created_at?=now
-    // }
-    expect(tokenMatcher(tokens.next(), SchemaToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), IntToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), TimestampToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Question)).to.be.true;
-    expect(tokenMatcher(tokens.next(), EqualToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NowToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    // index = [{...}, {...}, {...}]
-    expect(tokenMatcher(tokens.next(), IndexToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), EqualToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    // {type: "primary", field: [{name: "id"}]}
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), TypeToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), CommaToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), FieldToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    // {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), TypeToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), CommaToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), FieldToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), CommaToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    // {type: "btree", field: [{name: "created_at", op: "desc"}]}
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), TypeToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), CommaToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), FieldToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), LCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), CommaToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), Identifier)).to.be.true;
-    expect(tokenMatcher(tokens.next(), ColonToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), StringLiteral)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-
-    expect(tokenMatcher(tokens.next(), RSquare)).to.be.true;
-    expect(tokenMatcher(tokens.next(), NewlineToken)).to.be.true;
-    expect(tokenMatcher(tokens.next(), RCurly)).to.be.true;
-  });
-});

package/lexer/utils.spec.js

@@ -1,61 +0,0 @@
-import { expect } from "chai";
-import { beforeEach,describe, it } from "mocha";
-import {
-  __resetTokens,
-  createTokenByName,
-  createUniqToken,
-  sortUniqTokens,
-} from "./utils.js";
-
-describe("createUniqToken", () => {
-  beforeEach(() => {
-    __resetTokens();
-  });
-
-  it("creates a token with a unique pattern", () => {
-    const token1 = createUniqToken({ pattern: /foo/ });
-    const token2 = createUniqToken({ pattern: /foo/ });
-    expect(token1).to.equal(token2);
-  });
-});
-
-describe("createTokenByName", () => {
-  beforeEach(() => {
-    __resetTokens();
-  });
-
-  it("creates a token with a name derived from the given name", () => {
-    const token = createTokenByName("foo");
-    expect(token.name).to.equal("foo token");
-    expect(token.LABEL).to.equal("foo");
-    expect(new RegExp(token.pattern).test("foo")).to.be.true;
-  });
-
-  it("creates a token with a name derived from the given name", () => {
-    const token = createTokenByName("$remote_ip", { pattern: /\$remote_ip/ });
-    expect(token.name).to.equal("$remote_ip token");
-    expect(token.LABEL).to.equal("$remote_ip");
-  });
-
-  it("does not create duplicate tokens", () => {
-    const token1 = createTokenByName("foo");
-    const token2 = createTokenByName("foo");
-    expect(token1).to.equal(token2);
-  });
-
-  it("differentiate between lowercase and uppercase", () => {
-    const token_get = createTokenByName("get");
-    const token_GET = createTokenByName("GET");
-    expect(token_get.name).to.not.equal(token_GET.name);
-  });
-});
-
-describe("sortUniqTokens", () => {
-  it("sorts tokens by pattern length", () => {
-    const token1 = createUniqToken({ pattern: /foo/ });
-    const token2 = createUniqToken({ pattern: /fooBar/ });
-    const token3 = createUniqToken({ pattern: /fooBarBaz/ });
-    const tokens = sortUniqTokens([token1, token2, token3]);
-    expect(tokens).to.deep.equal([token3, token2, token1]);
-  });
-});

package/onCompletion/contentAssist.spec.js

@@ -1,275 +0,0 @@
-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");
-      });
-    });
-  });
-});