@xano/xanoscript-language-server 11.8.4 → 11.8.5

package/.claude/settings.local.json

@@ -19,7 +19,8 @@
       "Bash(then)",
       "Bash(echo:*)",
       "Bash(fi)",
-      "Bash(done)"
+      "Bash(done)",
+      "Bash(npx eslint:*)"
     ]
   }
 }

package/cache/documentCache.js

@@ -7,10 +7,13 @@ import { getSchemeFromContent } from "../utils.js";
  * Stores parse results keyed by document URI + version.
  * Note: We cache a snapshot of parser state, not the parser instance itself,
  * since the parser is a singleton that gets mutated on each parse.
+ *
+ * lexResult (token arrays) are NOT cached to reduce memory footprint.
+ * Lexing is fast (~1ms) and can be repeated when needed.
  */
 class DocumentCache {
   constructor() {
-    // Map<uri, { version: number, lexResult: Object, parserState: Object, scheme: string }>
+    // Map<uri, { version: number, textLength: number, parserState: Object, scheme: string }>
     this.cache = new Map();
   }
 
@@ -31,9 +34,9 @@ class DocumentCache {
       cached.version === version &&
       cached.textLength === textLength
     ) {
-      // Return cached result with a proxy parser object containing cached state
+      // Re-lex (cheap) to provide tokens; return cached parser state
       return {
-        lexResult: cached.lexResult,
+        lexResult: lexDocument(text),
         parser: cached.parserState,
         scheme: cached.scheme,
       };
@@ -44,21 +47,66 @@ class DocumentCache {
     const lexResult = lexDocument(text);
     const parser = xanoscriptParser(text, scheme, lexResult);
 
-    // Create a snapshot of the parser's state including symbol table
+    // Snapshot only the parser state we need - not the token arrays.
+    // Use structured clone to avoid retaining references to parser internals.
     const parserState = {
-      errors: [...parser.errors],
-      warnings: [...parser.warnings],
-      informations: [...parser.informations],
-      hints: [...parser.hints],
+      errors: parser.errors.map((e) => ({
+        message: e.message,
+        token: e.token
+          ? {
+              startOffset: e.token.startOffset,
+              endOffset: e.token.endOffset,
+            }
+          : null,
+      })),
+      warnings: parser.warnings.map((w) => ({
+        message: w.message,
+        token: w.token
+          ? {
+              startOffset: w.token.startOffset,
+              endOffset: w.token.endOffset,
+            }
+          : null,
+      })),
+      informations: parser.informations.map((i) => ({
+        message: i.message,
+        token: i.token
+          ? {
+              startOffset: i.token.startOffset,
+              endOffset: i.token.endOffset,
+            }
+          : null,
+      })),
+      hints: parser.hints.map((h) => ({
+        message: h.message,
+        token: h.token
+          ? {
+              startOffset: h.token.startOffset,
+              endOffset: h.token.endOffset,
+            }
+          : null,
+      })),
       __symbolTable: parser.__symbolTable
-        ? JSON.parse(JSON.stringify(parser.__symbolTable))
+        ? {
+            input: { ...parser.__symbolTable.input },
+            var: { ...parser.__symbolTable.var },
+            auth: { ...parser.__symbolTable.auth },
+            env: { ...parser.__symbolTable.env },
+            references: parser.__symbolTable.references.map((r) => ({
+              ...r,
+              args: r.args ? { ...r.args } : undefined,
+              dataKeys: r.dataKeys ? [...r.dataKeys] : undefined,
+            })),
+            varDeclarations: parser.__symbolTable.varDeclarations.map((d) => ({
+              ...d,
+            })),
+          }
         : null,
     };
 
     const cacheEntry = {
       version,
       textLength,
-      lexResult,
       parserState,
       scheme,
     };

package/lexer/db.js

@@ -190,9 +190,8 @@ export function mapTokenToType(token) {
     case TruncateToken.name:
     case DirectQueryToken.name:
     case SetDatasourceToken.name:
-      return "variable";
     case WhereToken.name:
-      return;
+      return "variable";
     default:
       return null;
   }

package/lexer/security.js

@@ -85,6 +85,18 @@ export const JweEncodeToken = createTokenByName("jwe_encode", {
   categories: [Identifier],
 });
 
+// jwe_decode_legacy
+export const JweDecodeLegacyToken = createTokenByName("jwe_decode_legacy", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// jwe_encode_legacy
+export const JweEncodeLegacyToken = createTokenByName("jwe_encode_legacy", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
 // jws_decode
 export const JwsDecodeToken = createTokenByName("jws_decode", {
   longer_alt: Identifier,
@@ -121,6 +133,8 @@ export const SecurityTokens = [
   EncryptToken,
   GeneratePassToken,
   GenerateUuidToken,
+  JweDecodeLegacyToken,
+  JweEncodeLegacyToken,
   JweDecodeToken,
   JweEncodeToken,
   JwsDecodeToken,
@@ -150,6 +164,8 @@ export function mapTokenToType(token) {
     case GenerateUuidToken.name:
     case JweDecodeToken.name:
     case JweEncodeToken.name:
+    case JweDecodeLegacyToken.name:
+    case JweEncodeLegacyToken.name:
     case JwsDecodeToken.name:
     case JwsEncodeToken.name:
     case RandomBytesToken.name:

package/onCompletion/onCompletion.js

@@ -1,5 +1,6 @@
 import { mapToVirtualJS } from "../embedded/embeddedContent.js";
 import { getSchemeFromContent } from "../utils.js";
+import { workspaceIndex } from "../workspace/workspaceIndex.js";
 import { getContentAssistSuggestions } from "./contentAssist.js";
 
 /**
@@ -33,6 +34,65 @@ export function onCompletion(params, documents) {
 
   // Otherwise, handle as regular XanoScript
   const scheme = getSchemeFromContent(text);
+  const prefix = text.slice(0, offset);
 
-  return getContentAssistSuggestions(text.slice(0, offset), scheme);
+  const suggestions = getContentAssistSuggestions(prefix, scheme);
+
+  // Add workspace object name completions
+  const workspaceCompletions = getWorkspaceCompletions(prefix);
+  if (workspaceCompletions) {
+    const existing = suggestions || [];
+    return [...existing, ...workspaceCompletions];
+  }
+
+  return suggestions;
+}
+
+/**
+ * Get completions for cross-file references based on cursor context.
+ * @param {string} prefix - Text before cursor
+ * @returns {Array|null} Completion items or null if not in a reference context
+ */
+function getWorkspaceCompletions(prefix) {
+  // function.run " or function.call " context
+  if (/function\.(run|call)\s+"[^"]*$/.test(prefix)) {
+    return workspaceIndex.getAllNames("function").map((name) => ({
+      label: name,
+      kind: 3, // Function
+      detail: "function",
+    }));
+  }
+
+  // task.call " context
+  if (/task\.call\s+"[^"]*$/.test(prefix)) {
+    return workspaceIndex.getAllNames("task").map((name) => ({
+      label: name,
+      kind: 3,
+      detail: "task",
+    }));
+  }
+
+  // db.* table name context
+  if (
+    /\b(get|add|edit|delete|query|patch|has|truncate|add_or_edit|schema)\s+("?[^"\s{]*$)/.test(
+      prefix
+    )
+  ) {
+    return workspaceIndex.getAllNames("table").map((name) => ({
+      label: name,
+      kind: 7, // Class (for table)
+      detail: "table",
+    }));
+  }
+
+  // api.call " context
+  if (/api\.call\s+"[^"]*$/.test(prefix)) {
+    return workspaceIndex.getAllNames("query").map((name) => ({
+      label: name,
+      kind: 3,
+      detail: "query",
+    }));
+  }
+
+  return null;
 }

package/onDefinition/onDefinition.js

@@ -0,0 +1,150 @@
+import { lexDocument } from "../lexer/lexer.js";
+import { LongFormVariable, ShortFormVariable } from "../lexer/variables.js";
+import { getVarName } from "../parser/generic/utils.js";
+import { xanoscriptParser } from "../parser/parser.js";
+
+// Token names that precede a table name reference
+const DB_OPERATION_TOKENS = new Set([
+  "get",
+  "add",
+  "edit",
+  "delete",
+  "query",
+  "patch",
+  "has",
+  "truncate",
+  "add_or_edit",
+  "schema",
+]);
+
+const SHORT_FORM = ShortFormVariable.name;
+const LONG_FORM = LongFormVariable.name;
+
+/**
+ * Find the definition location for the symbol at the given offset.
+ * @param {string} text - Document text
+ * @param {number} offset - Cursor offset in document
+ * @param {import('../workspace/workspaceIndex.js').WorkspaceIndex} index
+ * @param {Object} [symbolTable] - Parsed symbol table (optional, for variable lookups)
+ * @returns {{ uri: string, offset?: number } | null}
+ */
+export function findDefinition(text, offset, index, symbolTable) {
+  const lexResult = lexDocument(text);
+  const tokens = lexResult.tokens;
+
+  // Find the token at the cursor position
+  let tokenIndex = -1;
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i].startOffset <= offset && offset <= tokens[i].endOffset) {
+      tokenIndex = i;
+      break;
+    }
+  }
+
+  if (tokenIndex < 0) return null;
+
+  const token = tokens[tokenIndex];
+  const typeName = token.tokenType.name;
+
+  // Variable go-to-definition
+  if (typeName === SHORT_FORM || typeName === LONG_FORM) {
+    // Parse if no symbol table provided
+    const st =
+      symbolTable ||
+      xanoscriptParser(text, undefined, lexResult).__symbolTable;
+    return findVariableDefinition(tokens, tokenIndex, st);
+  }
+
+  // For LongFormVariable ($var), check if cursor is on the identifier after $var.
+  // e.g., "$var.foo" — cursor on "foo" (an Identifier token after DotToken after LongFormVariable)
+  if (
+    tokenIndex >= 2 &&
+    tokens[tokenIndex - 1].image === "." &&
+    tokens[tokenIndex - 2].tokenType.name === LONG_FORM
+  ) {
+    const st =
+      symbolTable ||
+      xanoscriptParser(text, undefined, lexResult).__symbolTable;
+    return findVariableDefinition(tokens, tokenIndex, st);
+  }
+
+  const name = getVarName(token);
+
+  // Look backwards to determine context (cross-file references)
+  for (let i = tokenIndex - 1; i >= 0 && i >= tokenIndex - 3; i--) {
+    const prevImage = tokens[i].image.toLowerCase();
+
+    if (prevImage === "run" || prevImage === "call") {
+      // Check what's before: function. or task. or api.
+      if (i >= 2 && tokens[i - 1].image === ".") {
+        const prefix = tokens[i - 2].image.toLowerCase();
+        if (prefix === "function") {
+          const entry = index.get("function", name);
+          return entry ? { uri: entry.uri } : null;
+        }
+        if (prefix === "task") {
+          const entry = index.get("task", name);
+          return entry ? { uri: entry.uri } : null;
+        }
+        if (prefix === "api") {
+          const entry = index.get("query", name);
+          return entry ? { uri: entry.uri } : null;
+        }
+      }
+    }
+
+    if (DB_OPERATION_TOKENS.has(prevImage)) {
+      const entry = index.get("table", name);
+      return entry ? { uri: entry.uri } : null;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Find the declaration offset for a variable token.
+ * @param {import('chevrotain').IToken[]} tokens
+ * @param {number} tokenIndex - Index of the token the cursor is on
+ * @param {Object} symbolTable
+ * @returns {{ offset: number } | null}
+ */
+function findVariableDefinition(tokens, tokenIndex, symbolTable) {
+  const declarations = symbolTable?.varDeclarations;
+  if (!declarations || declarations.length === 0) return null;
+
+  const token = tokens[tokenIndex];
+  const typeName = token.tokenType.name;
+
+  let varName;
+  if (typeName === SHORT_FORM) {
+    varName = token.image; // "$foo"
+  } else if (typeName === LONG_FORM) {
+    // $var.foo → resolve to $foo
+    if (tokenIndex + 2 < tokens.length) {
+      varName = `$${tokens[tokenIndex + 2].image}`;
+    } else {
+      return null;
+    }
+  } else {
+    // Cursor is on the identifier after "$var." (e.g., "foo" in "$var.foo")
+    varName = `$${token.image}`;
+  }
+
+  // Find the first declaration for this variable
+  const decl = declarations.find((d) => d.name === varName);
+  if (!decl || decl.startOffset == null) return null;
+
+  // Don't navigate if cursor is already on the declaration
+  if (token.startOffset === decl.startOffset) return null;
+  // For LongFormVariable, also check if the identifier token matches
+  if (
+    typeName === LONG_FORM &&
+    tokenIndex + 2 < tokens.length &&
+    tokens[tokenIndex + 2].startOffset === decl.startOffset
+  ) {
+    return null;
+  }
+
+  return { offset: decl.startOffset };
+}

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);
+  });
+});