@xano/xanoscript-language-server 11.8.3 → 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

@@ -13,6 +13,12 @@ export const QueryToken = createTokenByName("query", {
   categories: [Identifier],
 });
 
+// where
+export const WhereToken = createTokenByName("where", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
 // get
 export const GetToken = createTokenByName("get", {
   longer_alt: Identifier,
@@ -156,6 +162,7 @@ export const DbTokens = [
   MysqlToken,
   PostgresToken,
   OracleToken,
+  WhereToken,
 ];
 
 export function mapTokenToType(token) {
@@ -183,7 +190,8 @@ export function mapTokenToType(token) {
     case TruncateToken.name:
     case DirectQueryToken.name:
     case SetDatasourceToken.name:
-      return "function";
+    case WhereToken.name:
+      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 };
+}