@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/workspace/referenceTracking.spec.js

@@ -1,420 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { xanoscriptParser } from "../parser/parser.js";
-
-describe("reference tracking in __symbolTable", () => {
-  it("should track function.run reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.run "my_target" as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("function");
-    expect(refs[0].name).to.equal("my_target");
-    expect(refs[0].startOffset).to.be.a("number");
-  });
-
-  it("should track function.call reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.call "my_target" as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("function");
-    expect(refs[0].name).to.equal("my_target");
-  });
-
-  it("should track db.get table reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.get users {
-          field_name = id
-          field_value = 1
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("table");
-    expect(refs[0].name).to.equal("users");
-  });
-
-  it("should track db.query table reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.query users {
-          return {
-            type = list
-          }
-        } as $users
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("table");
-    expect(refs[0].name).to.equal("users");
-  });
-
-  it("should track multiple references in one file", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.get users {
-          field_name = "user_id"
-          field_value = 1
-        } as $user
-        function.run "helper" as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(2);
-    expect(refs[0].refType).to.equal("table");
-    expect(refs[0].name).to.equal("users");
-    expect(refs[1].refType).to.equal("function");
-    expect(refs[1].name).to.equal("helper");
-  });
-
-  it("should track task.call reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        task.call "my_task" as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("task");
-    expect(refs[0].name).to.equal("my_task");
-  });
-
-  it("should track db.bulk.delete table reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.bulk.delete users {
-          field_name = id
-          field_value = [1, 2, 3]
-        }
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("table");
-    expect(refs[0].name).to.equal("users");
-  });
-
-  it("should track string literal table names", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.get "user table" {
-          field_name = id
-          field_value = 1
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].name).to.equal("user table");
-  });
-
-  it("should capture input args on function.run reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.run "my_target" {
-          input = { user_id: 1, name: "test" }
-        } as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("function");
-    expect(refs[0].args).to.be.an("object");
-    expect(refs[0].args).to.have.property("user_id");
-    expect(refs[0].args).to.have.property("name");
-  });
-
-  it("should capture literal types on input args", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.run "my_target" {
-          input = { count: 100, name: "test", rate: 3.14, active: true }
-        } as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    const args = refs[0].args;
-    expect(args.count.type).to.equal("int");
-    expect(args.name.type).to.equal("text");
-    expect(args.rate.type).to.equal("decimal");
-    expect(args.active.type).to.equal("bool");
-  });
-
-  it("should capture input args with variable values as unknown type", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.run "my_target" {
-          input = { user_id: $var1 }
-        } as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].args).to.have.property("user_id");
-    expect(refs[0].args.user_id.type).to.be.null;
-  });
-
-  it("should not have args when function.run has no input", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.run "my_target" as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].args).to.be.undefined;
-  });
-
-  it("should not have args when function.run has non-input attributes only", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        function.run "my_target" {
-          description = "testing"
-        } as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].args).to.be.undefined;
-  });
-
-  it("should capture field_name on db.get reference with string literal", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.get users {
-          field_name = "id"
-          field_value = 1
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("table");
-    expect(refs[0].fieldName).to.equal("id");
-  });
-
-  it("should capture field_name on db.edit reference with string literal", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.edit users {
-          field_name = "id"
-          field_value = 1
-          data = { name: "test" }
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].fieldName).to.equal("id");
-  });
-
-  it("should not capture field_name when value is a variable expression", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.get users {
-          field_name = $input.field
-          field_value = 1
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].fieldName).to.be.undefined;
-  });
-
-  it("should not have field_name when db function has no field_name attribute", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.query users {
-          return {
-            type = list
-          }
-        } as $users
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].fieldName).to.be.undefined;
-  });
-
-  it("should track middleware references from query middleware clause", () => {
-    const parser = xanoscriptParser(`query foo verb=GET {
-      input {
-        text user_id filters=trim
-      }
-
-      stack {
-      }
-
-      response = null
-
-      middleware = {pre: [{name: "auth_middle"}], post: [{name: "log_middle"}]}
-    }`);
-    const refs = parser.__symbolTable.references;
-    const mwRefs = refs.filter((r) => r.refType === "middleware");
-    expect(mwRefs).to.have.length(2);
-    expect(mwRefs[0].name).to.equal("auth_middle");
-    expect(mwRefs[1].name).to.equal("log_middle");
-  });
-
-  it("should track middleware.call reference", () => {
-    const parser = xanoscriptParser(`workflow_test test_middleware {
-      stack {
-        middleware.call "auth_check" {
-          input = {
-            vars: $input,
-            type: "pre"
-          }
-        } as $result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    const mwRefs = refs.filter((r) => r.refType === "middleware");
-    expect(mwRefs).to.have.length(1);
-    expect(mwRefs[0].name).to.equal("auth_check");
-  });
-
-  it("should track data keys on db.edit reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.edit users {
-          field_name = "id"
-          field_value = 1
-          data = { name: "test", email: "foo@bar.com" }
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].refType).to.equal("table");
-    expect(refs[0].dataKeys).to.be.an("array");
-    const keyNames = refs[0].dataKeys.map((k) => k.name);
-    expect(keyNames).to.include("name");
-    expect(keyNames).to.include("email");
-  });
-
-  it("should not have dataKeys when db function has no data attribute", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.get users {
-          field_name = "id"
-          field_value = 1
-        } as $user
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    expect(refs).to.have.length(1);
-    expect(refs[0].dataKeys).to.be.undefined;
-  });
-
-  it("should track join table references in db.query", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.query users {
-          join = {
-            profile: {
-              type: "left"
-              table: "user_profiles"
-            }
-          }
-          return = {type: "list"}
-        } as $users
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    const tableRefs = refs.filter((r) => r.refType === "table");
-    expect(tableRefs).to.have.length(2);
-    expect(tableRefs[0].name).to.equal("users");
-    expect(tableRefs[1].name).to.equal("user_profiles");
-  });
-
-  it("should track addon name references in db.query", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.query users {
-          addon = [{name: "get_posts", as: "_posts"}]
-          return = {type: "list"}
-        } as $users
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    const fnRefs = refs.filter((r) => r.refType === "function");
-    expect(fnRefs).to.have.length(1);
-    expect(fnRefs[0].name).to.equal("get_posts");
-  });
-
-  it("should track table relation references from column definitions", () => {
-    const parser = xanoscriptParser(`table beer {
-      schema {
-        int brewery_id {
-          table = "brewery"
-        }
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    const tableRefs = refs.filter((r) => r.refType === "table");
-    expect(tableRefs).to.have.length(1);
-    expect(tableRefs[0].name).to.equal("brewery");
-  });
-
-  it("should track function.run with empty name and not leak args to previous reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        db.edit claim {
-          field_name = "id"
-          field_value = 1
-          data = {status: "active"}
-        } as $updated_claim
-
-        function.run "" {
-          input = {
-            claim_id: 1
-            to_status: "assessment"
-          }
-        } as $transition_result
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    const tableRefs = refs.filter((r) => r.refType === "table");
-    const fnRefs = refs.filter((r) => r.refType === "function");
-
-    // The table ref should NOT have args from the function.run
-    expect(tableRefs).to.have.length(1);
-    expect(tableRefs[0].name).to.equal("claim");
-    expect(tableRefs[0].args).to.be.undefined;
-
-    // The function ref should exist (even with empty name) and carry the args
-    expect(fnRefs).to.have.length(1);
-    expect(fnRefs[0].name).to.equal("");
-    expect(fnRefs[0].args).to.have.property("claim_id");
-    expect(fnRefs[0].args).to.have.property("to_status");
-  });
-
-  it("should track security.create_auth_token table reference", () => {
-    const parser = xanoscriptParser(`function "caller" {
-      stack {
-        security.create_auth_token {
-          table = "users"
-          extras = {}
-          expiration = 86400
-          id = ""
-        } as $token
-      }
-    }`);
-    const refs = parser.__symbolTable.references;
-    const tableRefs = refs.filter((r) => r.refType === "table");
-    expect(tableRefs).to.have.length(1);
-    expect(tableRefs[0].name).to.equal("users");
-  });
-});

package/workspace/workspaceIndex.spec.js

@@ -1,189 +0,0 @@
-import { expect } from "chai";
-import { beforeEach, describe, it } from "mocha";
-import { xanoscriptParser } from "../parser/parser.js";
-import { getSchemeFromContent } from "../utils.js";
-import { WorkspaceIndex } from "./workspaceIndex.js";
-
-/**
- * Helper to add a file with pre-parsed inputs (simulates what onDidChangeContent does).
- */
-function addWithInputs(index, uri, content) {
-  const scheme = getSchemeFromContent(content);
-  const parser = xanoscriptParser(content, scheme);
-  return index.addParsed(uri, content, parser.__symbolTable);
-}
-
-describe("WorkspaceIndex", () => {
-  let index;
-
-  beforeEach(() => {
-    index = new WorkspaceIndex();
-  });
-
-  describe("addFile (lightweight indexing)", () => {
-    it("should index type and name from a function file", () => {
-      index.addFile(
-        "file:///workspace/my_func.xs",
-        `function "my_func" {
-        input {
-          int user_id
-          text? name
-        }
-      }`
-      );
-      expect(index.has("function", "my_func")).to.be.true;
-      const entry = index.getByUri("file:///workspace/my_func.xs");
-      expect(entry.type).to.equal("function");
-      expect(entry.name).to.equal("my_func");
-    });
-
-    it("should index a query file", () => {
-      index.addFile(
-        "file:///workspace/get_users.xs",
-        'query "/users" GET {\n}'
-      );
-      expect(index.has("query", "/users")).to.be.true;
-    });
-
-    it("should index a task file", () => {
-      index.addFile(
-        "file:///workspace/cleanup.xs",
-        'task "daily_cleanup" {\n}'
-      );
-      expect(index.has("task", "daily_cleanup")).to.be.true;
-    });
-
-    it("should return false for unparseable content", () => {
-      const result = index.addFile("file:///workspace/bad.xs", "not valid");
-      expect(result).to.be.false;
-    });
-
-    it("should update entry when file content changes", () => {
-      index.addFile(
-        "file:///workspace/my_func.xs",
-        'function "my_func" {\n}'
-      );
-      index.addFile(
-        "file:///workspace/my_func.xs",
-        'function "renamed" {\n}'
-      );
-      expect(index.has("function", "my_func")).to.be.false;
-      expect(index.has("function", "renamed")).to.be.true;
-    });
-  });
-
-  describe("addParsed (with inputs)", () => {
-    it("should index a function file with inputs", () => {
-      const content = `function "my_func" {
-        input {
-          int user_id
-          text? name
-        }
-      }`;
-      addWithInputs(index, "file:///workspace/my_func.xs", content);
-      const entry = index.get("function", "my_func");
-      expect(entry).to.exist;
-      expect(entry.uri).to.equal("file:///workspace/my_func.xs");
-      expect(entry.type).to.equal("function");
-      expect(entry.name).to.equal("my_func");
-      expect(entry.inputs).to.have.property("user_id");
-      expect(entry.inputs.user_id.type).to.equal("int");
-      expect(entry.inputs.name.nullable).to.be.true;
-    });
-
-    it("should index a table file with columns", () => {
-      const content = `table users {
-        schema {
-          int id
-          text name
-          timestamp created_at?=now
-        }
-      }`;
-      addWithInputs(index, "file:///workspace/users.xs", content);
-      const entry = index.get("table", "users");
-      expect(entry).to.exist;
-      expect(entry.name).to.equal("users");
-      expect(entry.inputs).to.have.property("id");
-      expect(entry.inputs.id.type).to.equal("int");
-      expect(entry.inputs).to.have.property("name");
-      expect(entry.inputs.name.type).to.equal("text");
-      expect(entry.inputs.created_at.optional).to.be.true;
-    });
-  });
-
-  describe("removeFile", () => {
-    it("should remove an indexed file", () => {
-      index.addFile(
-        "file:///workspace/my_func.xs",
-        'function "my_func" {\n}'
-      );
-      index.removeFile("file:///workspace/my_func.xs");
-      expect(index.get("function", "my_func")).to.be.undefined;
-    });
-
-    it("should be a no-op for unknown URIs", () => {
-      index.removeFile("file:///workspace/unknown.xs");
-      // No error thrown
-    });
-  });
-
-  describe("getByType", () => {
-    it("should return all entries for a type", () => {
-      index.addFile("file:///workspace/a.xs", 'function "func_a" {\n}');
-      index.addFile("file:///workspace/b.xs", 'function "func_b" {\n}');
-      index.addFile("file:///workspace/t.xs", "table users {\n}");
-
-      const functions = index.getByType("function");
-      expect(functions).to.have.length(2);
-      expect(functions.map((f) => f.name)).to.include.members([
-        "func_a",
-        "func_b",
-      ]);
-    });
-
-    it("should return empty array for unknown type", () => {
-      expect(index.getByType("function")).to.deep.equal([]);
-    });
-  });
-
-  describe("has", () => {
-    it("should return true for indexed entries", () => {
-      index.addFile("file:///workspace/a.xs", 'function "my_func" {\n}');
-      expect(index.has("function", "my_func")).to.be.true;
-    });
-
-    it("should return false for missing entries", () => {
-      expect(index.has("function", "nonexistent")).to.be.false;
-    });
-  });
-
-  describe("getAllNames", () => {
-    it("should return all names for a type", () => {
-      index.addFile("file:///workspace/a.xs", 'function "func_a" {\n}');
-      index.addFile("file:///workspace/b.xs", 'function "func_b" {\n}');
-      const names = index.getAllNames("function");
-      expect(names).to.include.members(["func_a", "func_b"]);
-    });
-  });
-
-  describe("uri reverse lookup", () => {
-    it("should find entry by URI", () => {
-      index.addFile("file:///workspace/a.xs", 'function "my_func" {\n}');
-      const entry = index.getByUri("file:///workspace/a.xs");
-      expect(entry).to.exist;
-      expect(entry.name).to.equal("my_func");
-      expect(entry.type).to.equal("function");
-    });
-  });
-
-  describe("name collision", () => {
-    it("should overwrite when two files define same type+name", () => {
-      index.addFile("file:///workspace/a.xs", 'function "helper" {\n}');
-      index.addFile("file:///workspace/b.xs", 'function "helper" {\n}');
-      const entry = index.get("function", "helper");
-      expect(entry).to.exist;
-      expect(entry.uri).to.equal("file:///workspace/b.xs");
-      expect(index.getByUri("file:///workspace/a.xs")).to.be.undefined;
-    });
-  });
-});