@xano/xanoscript-language-server 11.12.2 → 12.0.0

package/lexer/comment.spec.js

@@ -1,77 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { CommentToken, CommentTokens } from "./comment.js";
-import { lexDocument } from "./lexer.js";
-
-describe("Comment Lexer", () => {
-  describe("CommentToken", () => {
-    it("should match a simple comment", () => {
-      const input = "// This is a comment";
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      expect(result.tokens).to.have.length(1);
-      expect(result.tokens[0].tokenType).to.equal(CommentToken);
-      expect(result.tokens[0].image).to.equal("// This is a comment");
-    });
-
-    it("should match comment with special characters", () => {
-      const input = "// TODO: Fix this bug @user123!";
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      expect(result.tokens).to.have.length(1);
-      expect(result.tokens[0].tokenType).to.equal(CommentToken);
-      expect(result.tokens[0].image).to.equal(
-        "// TODO: Fix this bug @user123!"
-      );
-    });
-
-    it("should match empty comment", () => {
-      const input = "//";
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      expect(result.tokens).to.have.length(1);
-      expect(result.tokens[0].tokenType).to.equal(CommentToken);
-      expect(result.tokens[0].image).to.equal("//");
-    });
-
-    it("should NOT match // in the middle of a line", () => {
-      const input = "some code // comment";
-      const result = lexDocument(input);
-
-      // Comments are only allowed on their own line (with optional leading whitespace)
-      // So // in the middle of a line should be tokenized as division operators
-      expect(result.errors).to.be.empty;
-      const commentTokens = result.tokens.filter(
-        (token) => token.tokenType === CommentToken
-      );
-      expect(commentTokens).to.have.length(0); // No comment token should be found
-    });
-
-    it("should handle multiple lines with comments", () => {
-      const input = `// First comment
-   // Second comment
-some code
-      // Third comment`;
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      const commentTokens = result.tokens.filter(
-        (token) => token.tokenType === CommentToken
-      );
-      expect(commentTokens).to.have.length(3);
-      expect(commentTokens[0].image).to.equal("// First comment");
-      expect(commentTokens[1].image).to.equal("// Second comment");
-      expect(commentTokens[2].image).to.equal("// Third comment");
-    });
-  });
-
-  describe("CommentTokens export", () => {
-    it("should export CommentTokens array", () => {
-      expect(CommentTokens).to.be.an("array");
-      expect(CommentTokens).to.include(CommentToken);
-    });
-  });
-});

package/lexer/multiline.spec.js

@@ -1,179 +0,0 @@
-import { expect } from "chai";
-import { Lexer } from "chevrotain";
-import { describe, it } from "mocha";
-import { MultiLineExpressionToken, MultiLineStringToken } from "./multiline.js";
-
-describe("MultiLineStringToken", () => {
-  const lexer = new Lexer([MultiLineStringToken, MultiLineExpressionToken]);
-
-  it("should match a valid multiline string with content LF", () => {
-    const input = '"""\nThis is a multiline string.\n   """';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a valid multiline string with content CRLF", () => {
-    const input = '"""\r\nThis is a multiline string.\r\n   """';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a valid multiline expression with content", () => {
-    const input = '```\n{"x": "test"}\n   ```';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineExpressionToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a valid multiline string with content (single quote)", () => {
-    const input = "'''\nThis is a multiline string.\n   '''";
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a valid empty multiline string", () => {
-    const input = '"""\n"""';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-  it("should match a valid empty multiline string (single quotes)", () => {
-    const input = "'''\n'''";
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a valid empty multiline expression", () => {
-    const input = "```\n```";
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineExpressionToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a multiline string with a single string quote sentence inside", () => {
-    const input = '"""\nconsole.log("quoted"); // sentence.\n"""';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should match a multiline string followed by other content", () => {
-    const input = '"""\nContent here\n """\nnextToken';
-    const result = lexer.tokenize(input);
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: '"""\nContent here\n """',
-      startOffset: 0,
-    });
-    // Errors for '\nnextToken' are expected
-  });
-
-  it("should reject a multiline string with no newline after opening quotes", () => {
-    const input = '""" Content\n"""';
-    const result = lexer.tokenize(input);
-    expect(result.tokens).to.be.empty;
-    expect(result.errors).to.not.be.empty;
-  });
-
-  it("should reject a multiline string with non-space characters before closing quotes", () => {
-    const input = '"""\nContent\nfoo """';
-    const result = lexer.tokenize(input);
-    expect(result.tokens).to.be.empty;
-    expect(result.errors).to.not.be.empty;
-  });
-
-  it("should reject a multiline string with tabs before closing quotes", () => {
-    const input = '"""\nContent\n\t"""';
-    const result = lexer.tokenize(input);
-    expect(result.tokens).to.be.empty;
-    expect(result.errors).to.not.be.empty;
-  });
-
-  it("should reject a multiline expression with tabs before closing quotes", () => {
-    const input = "```\nContent\n\t```";
-    const result = lexer.tokenize(input);
-    expect(result.tokens).to.be.empty;
-    expect(result.errors).to.not.be.empty;
-  });
-
-  it("should handle internal opposite quotes correctly (double quotes)", () => {
-    const input = '"""\nThis has \'\'\' inside\n """';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should handle internal opposite quotes correctly (single quotes)", () => {
-    const input = "'''\nThis has \"\"\" inside\n '''";
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-
-  it("should handle internal triple quotes correctly", () => {
-    const input = '"""\nThis has """ inside\n """';
-    const result = lexer.tokenize(input);
-    expect(result.errors).to.be.empty;
-    expect(result.tokens).to.have.lengthOf(1);
-    expect(result.tokens[0]).to.include({
-      tokenType: MultiLineStringToken,
-      image: input,
-      startOffset: 0,
-    });
-  });
-});

package/lexer/regexp.spec.js

@@ -1,84 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "./lexer.js";
-
-function getTokenTypes(text) {
-  const result = lexDocument(text);
-  return {
-    tokens: result.tokens.map((t) => ({
-      type: t.tokenType.name,
-      image: t.image,
-    })),
-    errors: result.errors,
-  };
-}
-
-describe("RegExpToken lexer", () => {
-  it("should not lex a standalone regex without preceding colon", () => {
-    const { tokens } = getTokenTypes("/[^213]*/");
-    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
-    expect(regexpTokens).to.have.length(0);
-  });
-
-  it("should lex a regex after a colon", () => {
-    const { tokens, errors } = getTokenTypes("pattern:/[^213]*/");
-    expect(errors).to.be.empty;
-    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
-    expect(regexpTokens).to.have.length(1);
-    expect(regexpTokens[0].image).to.equal("/[^213]*/");
-  });
-
-  it("should lex / as divide after an identifier", () => {
-    const { tokens } = getTokenTypes("var_rel/55");
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(1);
-    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
-    expect(regexpTokens).to.have.length(0);
-  });
-
-  it("should lex / as divide after a number", () => {
-    const { tokens } = getTokenTypes("55/2");
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(1);
-    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
-    expect(regexpTokens).to.have.length(0);
-  });
-
-  it("should lex / as divide after closing paren", () => {
-    const { tokens } = getTokenTypes("(1+2)/3");
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(1);
-  });
-
-  it("should not capture division as regex in complex expressions", () => {
-    const { tokens, errors } = getTokenTypes("$SomeVar.0.var_rel/55");
-    expect(errors).to.be.empty;
-    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
-    expect(regexpTokens).to.have.length(0);
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(1);
-  });
-
-  it("should lex / as divide with spaces around it", () => {
-    const { tokens, errors } = getTokenTypes("$var /64");
-    expect(errors).to.be.empty;
-    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
-    expect(regexpTokens).to.have.length(0);
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(1);
-  });
-
-  it("should lex / as divide with space only before it", () => {
-    const { tokens, errors } = getTokenTypes("$var/ 64");
-    expect(errors).to.be.empty;
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(1);
-  });
-
-  it("should lex / as divide when no spaces around a value", () => {
-    const { tokens, errors } = getTokenTypes("$var /64/ 34");
-    expect(errors).to.be.empty;
-    const divideTokens = tokens.filter((t) => t.type === "Divide");
-    expect(divideTokens).to.have.length(2);
-  });
-});

package/lexer/tests/query/query_lexer.spec.js

@@ -1,36 +0,0 @@
-import { expect } from "chai";
-import { readdirSync, readFileSync } from "fs";
-import findLast from "lodash-es/findLast.js";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer.js";
-
-describe("Xanoscript Query Lexer", () => {
-  it("Can Lex valid query sources", () => {
-    const files = readdirSync("lexer/tests/query/valid_sources");
-    files.forEach((file) => {
-      const source = readFileSync(
-        `lexer/tests/query/valid_sources/${file}`,
-        "utf8"
-      );
-      const lexingResult = lexDocument(source);
-      const { errors, tokens } = lexingResult;
-      if (errors.length > 0) {
-        let richErrors = errors.map((error) => {
-          const previousToken = findLast(
-            tokens,
-            (token) => token.endOffset <= error.offset
-          );
-          return {
-            name: error.message,
-            file: `lexer/tests/query/valid_sources/${file}:${error.line}:${error.column}`,
-            "prev. Token": previousToken ? previousToken.image : "N/A",
-          };
-        });
-
-        console.table(richErrors);
-      }
-
-      expect(errors).to.be.empty;
-    });
-  });
-});

package/lexer/tests/query/valid_sources/basic_query.xs

@@ -1,44 +0,0 @@
-query xanoscript_all_basics verb=GET {
-  input {
-    text some_text_value filters=trim {
-      description = "and a description"
-      sensitive = true
-    }
-  }
-
-  stack {
-    var some_var {
-      value = $env.$remote_ip
-    }
-  
-    conditional {
-      if (`($some_var)|strlen > 4`) {
-        db.add 48 {
-          data = {id: "null", created_at: '"now"', "@meta": "null"}
-        } as empty1
-      }
-    
-      else {
-        api.request {
-          url = "https://api.example.com/webhook"
-          method = "GET"
-          params = `{"value": "yup it's long"}`
-        } as api1
-      }
-    }
-  
-    foreach (`["1","2","3","4","5","6"]`) {
-      each as item {
-        var.update some_var {
-          value = $some_var|concat:$item:" + "
-        }
-      
-        debug.log {
-          value = $some_var
-        }
-      }
-    }
-  }
-
-  response = $some_var
-}

package/lexer/tests/query/valid_sources/db_query.xs

@@ -1,77 +0,0 @@
-query db_query verb=GET {
-  input
-  stack {
-    db.query book {
-      where = `"book.id" == 123`
-      eval = [
-        {
-          name  : "book.name"
-          as    : "book_name"
-          filter: [
-            {name: "upper", disabled: true}
-            {name: "add", arg: [{value: 123}]}
-          ]
-        }
-      ]
-
-      return_aggregate = {
-        paging : {page: 1, per_page: 25, metadata: true}
-        sorting: [{sort: "book_name", order: "asc"}]
-        group  : [
-          {
-            name  : "book.name"
-            as    : "book_name"
-            filter: [{name: "lower"}]
-          }
-        ]
-        eval   : [
-          {name: "book.name", as: "book_name", filter: [{name: "sum"}]}
-        ]
-      }
-
-      external_classic = {
-        value      : "test"
-        permissions: {search: true, sort: true, page: true, per_page: false}
-      }
-
-      external = {
-        search  : "test"
-        sort    : "test"
-        page    : "test"
-        per_page: "test"
-        offset  : "test"
-      }
-
-      output = [
-        "itemsReceived"
-        "curPage"
-        "nextPage"
-        "prevPage"
-        "offset"
-        "perPage"
-        "items.book_name"
-      ]
-
-      addon = [
-        {
-          name  : "book"
-          as    : "_book"
-          offset: "items[]"
-          input : {book_id: "book_name"}
-          addon : [
-            {
-              name  : "book"
-              as    : "_book2222"
-              offset: "obj"
-              output: ["name", "name2"]
-              input : {book_id: $env.API_KEY}
-            }
-          ]
-        }
-      ]
-
-    } as book1
-  }
-  
-  response = null
-}

package/lexer/tests/query/valid_sources/empty_query.xs

@@ -1,5 +0,0 @@
-query empty_query verb=GET {
-  input
-  stack
-  response = null
-}

package/lexer/tests/query/valid_sources/header_query.xs

@@ -1,15 +0,0 @@
-query get_auth verb=GET {
-  input
-  stack {
-    var authToken {
-      value = "foo-bar"
-    }
-  
-    util.set_header {
-      value = "Set-Cookie: sessionId=your-session-id; HttpOnly; Secure; SameSite=None; Max-Age=3600"|string_replace:"your-session-id":$authToken
-      duplicates = "replace"
-    }
-  }
-
-  response = $authToken
-}

package/lexer/tests/table/basic_table.xs

@@ -1,17 +0,0 @@
-table empty {
-  auth = true
-  security = {
-    guid: "-iOFONN4cySSKJ0MTrPNojIWB5c"
-  }
-
-  schema {
-    int id
-    timestamp created_at?=now
-  }
-
-  index = [
-    {type: "primary", field: [{name: "id"}]} 
-    {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-    {type: "btree", field: [{name: "created_at", op: "desc"}]}
-  ]
-}

package/lexer/tests/table/empty_table.xs

@@ -1,3 +0,0 @@
-table empty {
-  auth = false
-}