@xano/xanoscript-language-server 11.8.4 → 11.9.0

package/onDefinition/onDefinition.spec.js

@@ -0,0 +1,313 @@
+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/onDidChangeContent/onDidChangeContent.js

@@ -1,4 +1,7 @@
 import { documentCache } from "../cache/documentCache.js";
+import { validateVariables } from "../parser/variableValidator.js";
+import { crossFileValidate } from "../workspace/crossFileValidator.js";
+import { workspaceIndex } from "../workspace/workspaceIndex.js";
 
 // Diagnostic severity constants
 const SEVERITY = {
@@ -56,7 +59,7 @@ function createDiagnostics(parser, document) {
  * @param {import('vscode-languageserver').Connection} connection
  * @returns
  */
-export function onDidChangeContent(params, connection) {
+export function onDidChangeContent(params, connection, features = {}) {
   const document = params.document;
 
   if (!document) {
@@ -71,16 +74,14 @@ export function onDidChangeContent(params, connection) {
 
   try {
     // Parse the XanoScript file using cache
-    const { parser, scheme } = documentCache.getOrParse(
+    const { lexResult, parser, scheme } = documentCache.getOrParse(
       document.uri,
       document.version,
       text,
     );
 
-    if (parser.errors.length === 0) {
-      // If parsing succeeds with no errors, send an empty diagnostics array
-      connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
-    }
+    // Update workspace index with already-parsed data (no re-parse needed)
+    workspaceIndex.addParsed(document.uri, text, parser.__symbolTable);
 
     for (const error of parser.errors) {
       console.error(
@@ -91,6 +92,52 @@ export function onDidChangeContent(params, connection) {
     // Create diagnostics in a single pass
     const diagnostics = createDiagnostics(parser, document);
 
+    // Run cross-file validation and append as warnings
+    if (features.crossFileValidation !== false && parser.__symbolTable?.references) {
+      const crossFileWarnings = crossFileValidate(
+        parser.__symbolTable.references,
+        workspaceIndex,
+      );
+      for (const warning of crossFileWarnings) {
+        diagnostics.push({
+          severity: SEVERITY.WARNING,
+          range: {
+            start: document.positionAt(warning.startOffset),
+            end: document.positionAt(warning.endOffset + 1),
+          },
+          message: warning.message,
+        });
+      }
+    }
+
+    // Run variable validation and append warnings/hints
+    if (features.variableValidation !== false && parser.__symbolTable?.varDeclarations) {
+      const varResult = validateVariables(
+        parser.__symbolTable,
+        lexResult.tokens,
+      );
+      for (const warning of varResult.warnings) {
+        diagnostics.push({
+          severity: SEVERITY.WARNING,
+          range: {
+            start: document.positionAt(warning.startOffset),
+            end: document.positionAt(warning.endOffset + 1),
+          },
+          message: warning.message,
+        });
+      }
+      for (const hint of varResult.hints) {
+        diagnostics.push({
+          severity: SEVERITY.HINT,
+          range: {
+            start: document.positionAt(hint.startOffset),
+            end: document.positionAt(hint.endOffset + 1),
+          },
+          message: hint.message,
+        });
+      }
+    }
+
     console.log(
       `onDidChangeContent(): sending diagnostic (${parser.errors.length} errors) for scheme:`,
       scheme,

package/onHover/functions.md

@@ -1538,6 +1538,34 @@ security.jwe_encode {
 
 Encodes a payload as a JSON Web Encryption (JWE) token with `headers`, `claims`, and a `key`. The `key_algorithm` (e.g., `A256KW`) and `content_algorithm` (e.g., `A256GCM`) secure the token, and `ttl` sets its validity (0 for no expiration). The token is stored in the variable defined by `as`, here `$encrypted_token`.
 
+# security.jwe_encode_legacy
+
+```xs
+security.jwe_encode_legacy {
+  payload = $jwt_payload
+  audience = "LegacyApp"
+  key = $env.magic_jwt_secret
+  key_algorithm = "A256KW"
+  content_algorithm = "A256CBC-HS512"
+} as $jwt
+```
+
+Encodes a payload as a JSON Web Encryption (JWE) token using legacy algorithms. The `payload` is the data to encrypt, `audience` specifies the intended recipient, and `key` is used for encryption. The `key_algorithm` (e.g., `A256KW`) and `content_algorithm` (e.g., `A256CBC-HS512`) secure the token. The resulting JWE token is stored in the variable defined by `as`, here `$jwt`.
+
+# security.jwe_decode_legacy
+
+```xs
+security.jwe_decode_legacy {
+  token = $input.magic_token
+  key = $env.magic_jwt_secret
+  audience = "LegacyApp"
+  key_algorithm = "A256KW"
+  content_algorithm = "A256CBC-HS512"
+} as $decoded_magic_token
+```
+
+Decodes a JSON Web Encryption (JWE) token that was encoded using legacy algorithms. The `token` is the JWE to decode, `key` is used for decryption, and `audience` specifies the expected recipient. The `key_algorithm` (e.g., `A256KW`) and `content_algorithm` (e.g., `A256CBC-HS512`) are used to properly decode the token. The decoded payload is stored in the variable defined by `as`, here `$decoded_magic_token`.
+
 # security.create_secret_key
 
 ```xs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.8.4",
+  "version": "11.9.0",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/base_parser.js

@@ -42,10 +42,16 @@ export class XanoBaseParser extends CstParser {
    * Add a variable to the registry
    * @param {string} name the name of the variable
    * @param {string} type the type of the variable (int, decimal, text, bool, etc)
-   * @param {boolean} nullable whether the variable is nullable
+   * @param {import('chevrotain').IToken} [token] the token for position tracking
    */
-  addVariable(name, type, value = null) {
-    this.__symbolTable.var[name] = { type, value };
+  addVariable(name, type, token = null) {
+    this.__symbolTable.var[name] = { type, value: null };
+    this.__symbolTable.varDeclarations.push({
+      name,
+      type,
+      startOffset: token?.startOffset ?? null,
+      endOffset: token?.endOffset ?? null,
+    });
   }
 
   /**
@@ -58,6 +64,56 @@ export class XanoBaseParser extends CstParser {
     this.__symbolTable.input[name] = { type, iterable, nullable, optional };
   }
 
+  /**
+   * Record a cross-file reference for validation.
+   * @param {string} refType - The type of object referenced ("function", "table", "query", "task")
+   * @param {string} name - The referenced object name
+   * @param {import('chevrotain').IToken} token - The token containing the name (for diagnostics positioning)
+   */
+  addReference(refType, name, token) {
+    if (name == null || !token) return;
+    this.__symbolTable.references.push({
+      refType,
+      name,
+      startOffset: token.startOffset,
+      endOffset: token.endOffset,
+    });
+  }
+
+  /**
+   * Attach argument keys to the most recent reference (for input validation).
+   * @param {Object} args - Map of argument names to { value, startOffset, endOffset }
+   */
+  setReferenceArgs(args) {
+    const refs = this.__symbolTable.references;
+    if (refs.length === 0) return;
+    refs[refs.length - 1].args = args;
+  }
+
+  /**
+   * Attach field_name to the most recent reference (for column validation).
+   * @param {string} fieldName - The field name value
+   * @param {number} startOffset
+   * @param {number} endOffset
+   */
+  setReferenceFieldName(fieldName, startOffset, endOffset) {
+    const refs = this.__symbolTable.references;
+    if (refs.length === 0) return;
+    refs[refs.length - 1].fieldName = fieldName;
+    refs[refs.length - 1].fieldNameStartOffset = startOffset;
+    refs[refs.length - 1].fieldNameEndOffset = endOffset;
+  }
+
+  /**
+   * Attach data keys to the most recent reference (for column validation).
+   * @param {Array<{name: string, startOffset: number, endOffset: number}>} dataKeys
+   */
+  setReferenceDataKeys(dataKeys) {
+    const refs = this.__symbolTable.references;
+    if (refs.length === 0) return;
+    refs[refs.length - 1].dataKeys = dataKeys;
+  }
+
   /**
    * Add a warning message to the parser
    * @param {*} message
@@ -244,6 +300,8 @@ export class XanoBaseParser extends CstParser {
       var: {},
       auth: {},
       env: {},
+      references: [],
+      varDeclarations: [],
     };
   }
 }

package/parser/clauses/middlewareClause.js

@@ -1,5 +1,6 @@
 import { EqualToken } from "../../lexer/control.js";
 import { MiddlewareToken } from "../../lexer/tokens.js";
+import { getVarName } from "../generic/utils.js";
 
 /**
  * response = $entries
@@ -12,6 +13,7 @@ export function middlewareClause($) {
 
     const parent = $.CONSUME(MiddlewareToken); // "middleware"
     $.CONSUME(EqualToken); // "="
+    const captured = {};
     $.SUBRULE($.schemaParseObjectFn, {
       ARGS: [
         parent,
@@ -31,9 +33,23 @@ export function middlewareClause($) {
             },
           ],
         },
+        captured,
       ],
     });
 
+    $.ACTION(() => {
+      for (const phase of ["pre", "post"]) {
+        const items = captured[phase]?.value;
+        if (!Array.isArray(items)) continue;
+        for (const item of items) {
+          const nameEntry = item.name;
+          if (!nameEntry?.value) continue;
+          const token = nameEntry.value;
+          $.addReference("middleware", getVarName(token), token);
+        }
+      }
+    });
+
     $.sectionStack.pop();
   };
 }

package/parser/definitions/columnDefinition.js

@@ -113,6 +113,11 @@ export function columnDefinition($) {
       ],
     });
 
+    // Track table reference from FK column definition
+    if (captured.table?.value) {
+      $.addReference("table", getVarName(captured.table.value), captured.table.value);
+    }
+
     if (inputTypeToken.image == "vector" && !captured.size) {
       $.addWarning(
         'Column named "vector" should have a size attribute defining its length.',

package/parser/functions/api/apiCallFn.js

@@ -10,6 +10,7 @@ import {
   VerbToken,
 } from "../../../lexer/query.js";
 import { Identifier } from "../../../lexer/tokens.js";
+import { getVarName } from "../../generic/utils.js";
 
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
@@ -36,10 +37,11 @@ export function apiCallFn($) {
       );
     }
 
-    $.OR([
-      { ALT: () => $.CONSUME(StringLiteral) }, // "foo/bar"
-      { ALT: () => $.CONSUME(Identifier) }, // foo
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.addReference("query", getVarName(nameToken), nameToken);
     $.CONSUME(VerbToken);
     $.CONSUME(EqualToken);
     $.OR1([

package/parser/functions/controls/functionCallFn.js

@@ -1,6 +1,7 @@
 import { CallToken, FunctionToken } from "../../../lexer/function.js";
 import { StringLiteral } from "../../../lexer/literal.js";
 import { DotToken, Identifier } from "../../../lexer/tokens.js";
+import { getVarName } from "../../generic/utils.js";
 
 /**
  *
@@ -17,10 +18,11 @@ export function functionCallFn($) {
     $.CONSUME(DotToken); // "."
     const fnToken = $.CONSUME(CallToken); // "call"
 
-    $.OR([
-      { ALT: () => $.CONSUME(Identifier) }, // user
-      { ALT: () => $.CONSUME1(StringLiteral) }, // "user/ auth"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(Identifier) },
+      { ALT: () => $.CONSUME1(StringLiteral) },
     ]);
+    $.addReference("function", getVarName(nameToken), nameToken);
 
     $.SUBRULE($.functionAttrReq, {
       ARGS: [