@xano/xanoscript-language-server 11.12.2 → 11.12.3

package/onDefinition/onDefinition.spec.js

@@ -1,313 +0,0 @@
-import { expect } from "chai";
-import { readFileSync } from "fs";
-import { before, beforeEach, describe, it } from "mocha";
-import { lexDocument } from "../lexer/lexer.js";
-import { xanoscriptParser } from "../parser/parser.js";
-import { WorkspaceIndex } from "../workspace/workspaceIndex.js";
-import { findDefinition } from "./onDefinition.js";
-
-describe("findDefinition", () => {
-  let index;
-
-  beforeEach(() => {
-    index = new WorkspaceIndex();
-    index.addFile("file:///ws/users.xs", "table users {\n  schema {\n  }\n}");
-    index.addFile("file:///ws/helper.xs", 'function "helper" {\n}');
-  });
-
-  it("should find definition for function.run reference", () => {
-    const text = `function "caller" {
-      stack {
-        function.run "helper" as $result
-      }
-    }`;
-    const offset = text.indexOf('"helper"') + 1;
-    const result = findDefinition(text, offset, index);
-    expect(result).to.exist;
-    expect(result.uri).to.equal("file:///ws/helper.xs");
-  });
-
-  it("should find definition for db.get reference", () => {
-    const text = `function "caller" {
-      stack {
-        db.get users {
-          field_name = "user_id"
-          field_value = 1
-        } as $user
-      }
-    }`;
-    const offset = text.indexOf("users") + 2;
-    const result = findDefinition(text, offset, index);
-    expect(result).to.exist;
-    expect(result.uri).to.equal("file:///ws/users.xs");
-  });
-
-  it("should return null when cursor is not on a reference", () => {
-    const text = `function "caller" {
-      stack {
-      }
-    }`;
-    const offset = text.indexOf("stack") + 2;
-    const result = findDefinition(text, offset, index);
-    expect(result).to.be.null;
-  });
-
-  it("should return null when reference target not in index", () => {
-    const text = `function "caller" {
-      stack {
-        function.run "unknown" as $result
-      }
-    }`;
-    const offset = text.indexOf('"unknown"') + 1;
-    const result = findDefinition(text, offset, index);
-    expect(result).to.be.null;
-  });
-});
-
-describe("findDefinition - variable go-to-definition with coverage_check.xs", () => {
-  let text;
-  let lexResult;
-  let st;
-  let index;
-  let tokens;
-
-  before(() => {
-    text = readFileSync(
-      new URL(
-        "../parser/tests/variable_test/coverage_check.xs",
-        import.meta.url,
-      ),
-      "utf8",
-    );
-    lexResult = lexDocument(text);
-    const parser = xanoscriptParser(text, undefined, lexResult);
-    st = { ...parser.__symbolTable };
-    st.varDeclarations = [...parser.__symbolTable.varDeclarations];
-    tokens = lexResult.tokens;
-    index = new WorkspaceIndex();
-  });
-
-  function lineOf(offset) {
-    return text.substring(0, offset).split("\n").length;
-  }
-
-  function findAtLine(line, varImage) {
-    // Find token matching varImage on the given line
-    for (const t of tokens) {
-      if (t.image === varImage && lineOf(t.startOffset) === line) {
-        return findDefinition(text, t.startOffset, index, st);
-      }
-    }
-    throw new Error(`Token '${varImage}' not found on line ${line}`);
-  }
-
-  // --- Declarations should return NULL (already at definition) ---
-
-  it("L26: as $vehicle (declaration) -> null", () => {
-    expect(findAtLine(26, "$vehicle")).to.be.null;
-  });
-
-  it("L35: var $unused_variable (declaration) -> null", () => {
-    expect(findAtLine(35, "$unused_variable")).to.be.null;
-  });
-
-  it("L63: as $policy (declaration) -> null", () => {
-    expect(findAtLine(63, "$policy")).to.be.null;
-  });
-
-  it("L109: each as $pc (declaration) -> null", () => {
-    expect(findAtLine(109, "$pc")).to.be.null;
-  });
-
-  it("L160: each as $claim (declaration) -> null", () => {
-    expect(findAtLine(160, "$claim")).to.be.null;
-  });
-
-  // --- Built-in $db should return NULL ---
-
-  it("L19: $db (built-in) -> null", () => {
-    expect(findAtLine(19, "$db")).to.be.null;
-  });
-
-  // --- Usages should resolve to correct declaration line ---
-
-  it("L29: $vehicle in precondition -> decl at L26", () => {
-    const r = findAtLine(29, "$vehicle");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(26);
-  });
-
-  it("L42: $vehicle.vin in var value -> decl at L26", () => {
-    const r = findAtLine(42, "$vehicle");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(26);
-  });
-
-  it("L57: $vehicle.id in db.query where -> decl at L26", () => {
-    const r = findAtLine(57, "$vehicle");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(26);
-  });
-
-  it("L82: $policy in conditional if -> decl at L63", () => {
-    const r = findAtLine(82, "$policy");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(63);
-  });
-
-  it("L87: $policy_response in var.update -> decl at L66", () => {
-    const r = findAtLine(87, "$policy_response");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(66);
-  });
-
-  it("L89: $policy.policy_number in value -> decl at L63", () => {
-    const r = findAtLine(89, "$policy");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(63);
-  });
-
-  it("L108: $policy_coverages in foreach -> decl at L105", () => {
-    const r = findAtLine(108, "$policy_coverages");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(105);
-  });
-
-  it("L112: $pc.coverage_type_id in field_value -> decl at L109", () => {
-    const r = findAtLine(112, "$pc");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(109);
-  });
-
-  it("L118: $ctype.code in value -> decl at L113", () => {
-    const r = findAtLine(118, "$ctype");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(113);
-  });
-
-  it("L127: $coverages_response in array.push -> decl at L70", () => {
-    const r = findAtLine(127, "$coverages_response");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(70);
-  });
-
-  it("L128: $coverage_item in value -> decl at L116", () => {
-    const r = findAtLine(128, "$coverage_item");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(116);
-  });
-
-  it("L146: $all_claims in value -> decl at L142", () => {
-    const r = findAtLine(146, "$all_claims");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(142);
-  });
-
-  it("L163: $claim.incident_date in value -> decl at L160", () => {
-    const r = findAtLine(163, "$claim");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(160);
-  });
-
-  it("L168: $claim_date_ts in conditional if -> decl at L162", () => {
-    const r = findAtLine(168, "$claim_date_ts");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(162);
-  });
-
-  it("L168: $two_years_ago in conditional if -> decl at L150", () => {
-    const r = findAtLine(168, "$two_years_ago");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(150);
-  });
-
-  it("L179: $recent_claims_list in array.push -> decl at L155", () => {
-    const r = findAtLine(179, "$recent_claims_list");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(155);
-  });
-
-  it("L180: $recent_claim_item in value -> decl at L169", () => {
-    const r = findAtLine(180, "$recent_claim_item");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(169);
-  });
-
-  it("L188: $claims_summary in var.update -> decl at L74", () => {
-    const r = findAtLine(188, "$claims_summary");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(74);
-  });
-
-  it("L190: $total_claims_count in value -> decl at L145", () => {
-    const r = findAtLine(190, "$total_claims_count");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(145);
-  });
-
-  it("L216: $shop in conditional if -> decl at L212", () => {
-    const r = findAtLine(216, "$shop");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(212);
-  });
-
-  it("L217: $queried_by in var.update -> decl at L202", () => {
-    const r = findAtLine(217, "$queried_by");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(202);
-  });
-
-  it("L232: $vehicle_response in final result -> decl at L40", () => {
-    const r = findAtLine(232, "$vehicle_response");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(40);
-  });
-
-  it("L233: $policy_response in final result -> decl at L66", () => {
-    const r = findAtLine(233, "$policy_response");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(66);
-  });
-
-  it("L234: $coverages_response in final result -> decl at L70", () => {
-    const r = findAtLine(234, "$coverages_response");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(70);
-  });
-
-  it("L235: $claims_summary in final result -> decl at L74", () => {
-    const r = findAtLine(235, "$claims_summary");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(74);
-  });
-
-  it("L241: $queried_by in conditional if -> decl at L202", () => {
-    const r = findAtLine(241, "$queried_by");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(202);
-  });
-
-  it("L242: $result in var.update -> decl at L230", () => {
-    const r = findAtLine(242, "$result");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(230);
-  });
-
-  it("L243: $result in value expression -> decl at L230", () => {
-    const r = findAtLine(243, "$result");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(230);
-  });
-
-  it("L243: $queried_by in value expression -> decl at L202", () => {
-    const r = findAtLine(243, "$queried_by");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(202);
-  });
-
-  it("L251: $result in response = -> decl at L230", () => {
-    const r = findAtLine(251, "$result");
-    expect(r).to.exist;
-    expect(lineOf(r.offset)).to.equal(230);
-  });
-});

package/onHover/FilterMessageProvider.spec.js

@@ -1,85 +0,0 @@
-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.spec.js

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