@xano/xanoscript-language-server 11.8.4 → 11.9.0

package/workspace/referenceTracking.spec.js

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

@@ -0,0 +1,149 @@
+import { getObjectInfoFromContent } from "../utils.js";
+
+/**
+ * @typedef {Object} IndexEntry
+ * @property {string} uri - Document URI
+ * @property {string} type - Object type (function, table, query, task, etc.)
+ * @property {string} name - Object name
+ * @property {Object} [inputs] - Input parameters/columns from __symbolTable.input
+ */
+
+/**
+ * In-memory index of all XanoScript objects in the workspace.
+ * One entry per .xs file, keyed by (type, name).
+ */
+export class WorkspaceIndex {
+  constructor() {
+    /** @type {Map<string, Map<string, IndexEntry>>} type -> name -> entry */
+    this.index = new Map();
+    /** @type {Map<string, IndexEntry>} uri -> entry (reverse lookup) */
+    this.byUri = new Map();
+  }
+
+  /**
+   * @private
+   * Insert an entry into the index maps.
+   */
+  _setEntry(entry) {
+    const { type, name, uri } = entry;
+    if (!this.index.has(type)) {
+      this.index.set(type, new Map());
+    }
+
+    const existing = this.index.get(type).get(name);
+    if (existing && existing.uri !== uri) {
+      this.byUri.delete(existing.uri);
+    }
+
+    this.index.get(type).set(name, entry);
+    this.byUri.set(uri, entry);
+  }
+
+  /**
+   * Lightweight index: extract type+name via regex only (no parsing).
+   * Used for initial workspace scan to avoid heavy memory usage.
+   * Inputs will be populated later when the file is opened or parsed.
+   * @param {string} uri - Document URI
+   * @param {string} content - File content
+   * @returns {boolean} true if successfully indexed
+   */
+  addFile(uri, content) {
+    this.removeFile(uri);
+
+    const info = getObjectInfoFromContent(content);
+    if (!info) return false;
+
+    const entry = { uri, type: info.type, name: info.name, inputs: {} };
+    this._setEntry(entry);
+    return true;
+  }
+
+  /**
+   * Add or update a file in the index using pre-parsed data.
+   * Avoids double-parsing when the caller already has the parse result.
+   * @param {string} uri - Document URI
+   * @param {string} content - File content (for name extraction)
+   * @param {Object} symbolTable - Parser's __symbolTable
+   * @returns {boolean} true if successfully indexed
+   */
+  addParsed(uri, content, symbolTable) {
+    this.removeFile(uri);
+
+    const info = getObjectInfoFromContent(content);
+    if (!info) return false;
+
+    const inputs = symbolTable?.input ? { ...symbolTable.input } : {};
+    const entry = { uri, type: info.type, name: info.name, inputs };
+    this._setEntry(entry);
+    return true;
+  }
+
+  /**
+   * Remove a file from the index.
+   * @param {string} uri - Document URI
+   */
+  removeFile(uri) {
+    const existing = this.byUri.get(uri);
+    if (existing) {
+      const typeMap = this.index.get(existing.type);
+      if (typeMap) {
+        typeMap.delete(existing.name);
+        if (typeMap.size === 0) {
+          this.index.delete(existing.type);
+        }
+      }
+      this.byUri.delete(uri);
+    }
+  }
+
+  /**
+   * Get an index entry by type and name.
+   * @param {string} type
+   * @param {string} name
+   * @returns {IndexEntry | undefined}
+   */
+  get(type, name) {
+    return this.index.get(type)?.get(name);
+  }
+
+  /**
+   * Check if an entry exists.
+   * @param {string} type
+   * @param {string} name
+   * @returns {boolean}
+   */
+  has(type, name) {
+    return this.index.get(type)?.has(name) ?? false;
+  }
+
+  /**
+   * Get all entries for a given type.
+   * @param {string} type
+   * @returns {IndexEntry[]}
+   */
+  getByType(type) {
+    const typeMap = this.index.get(type);
+    return typeMap ? [...typeMap.values()] : [];
+  }
+
+  /**
+   * Get all names for a given type.
+   * @param {string} type
+   * @returns {string[]}
+   */
+  getAllNames(type) {
+    const typeMap = this.index.get(type);
+    return typeMap ? [...typeMap.keys()] : [];
+  }
+
+  /**
+   * Get entry by URI (reverse lookup).
+   * @param {string} uri
+   * @returns {IndexEntry | undefined}
+   */
+  getByUri(uri) {
+    return this.byUri.get(uri);
+  }
+}
+
+export const workspaceIndex = new WorkspaceIndex();