@xano/xanoscript-language-server 11.0.4 → 11.0.6

package/.claude/settings.local.json

@@ -26,7 +26,9 @@
       "Bash(npm whoami:*)",
       "Bash(npm view:*)",
       "Bash(npm version:*)",
-      "Bash(npm publish:*)"
+      "Bash(npm publish:*)",
+      "Bash(wc:*)",
+      "Bash(git push:*)"
     ],
     "deny": [],
     "ask": []

package/cache/documentCache.js

@@ -0,0 +1,91 @@
+import { lexDocument } from "../lexer/lexer.js";
+import { xanoscriptParser } from "../parser/parser.js";
+import { getSchemeFromContent } from "../utils.js";
+
+/**
+ * Cache for parsed documents to avoid redundant parsing.
+ * 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.
+ */
+class DocumentCache {
+  constructor() {
+    // Map<uri, { version: number, lexResult: Object, parserState: Object, scheme: string }>
+    this.cache = new Map();
+  }
+
+  /**
+   * Get cached parse result or parse and cache if not available.
+   * @param {string} uri - Document URI
+   * @param {number} version - Document version
+   * @param {string} text - Document text
+   * @returns {{ lexResult: Object, parser: Object, scheme: string }}
+   */
+  getOrParse(uri, version, text) {
+    const cached = this.cache.get(uri);
+    const textLength = text.length;
+
+    // Check version and text length to detect same URI with different content (e.g., in tests)
+    if (
+      cached &&
+      cached.version === version &&
+      cached.textLength === textLength
+    ) {
+      // Return cached result with a proxy parser object containing cached state
+      return {
+        lexResult: cached.lexResult,
+        parser: cached.parserState,
+        scheme: cached.scheme,
+      };
+    }
+
+    // Parse and cache a snapshot of the parser state
+    const scheme = getSchemeFromContent(text);
+    const lexResult = lexDocument(text);
+    const parser = xanoscriptParser(text, scheme, lexResult);
+
+    // Create a snapshot of the parser's state including symbol table
+    const parserState = {
+      errors: [...parser.errors],
+      warnings: [...parser.warnings],
+      informations: [...parser.informations],
+      hints: [...parser.hints],
+      __symbolTable: parser.__symbolTable
+        ? JSON.parse(JSON.stringify(parser.__symbolTable))
+        : null,
+    };
+
+    const cacheEntry = {
+      version,
+      textLength,
+      lexResult,
+      parserState,
+      scheme,
+    };
+
+    this.cache.set(uri, cacheEntry);
+
+    return {
+      lexResult,
+      parser: parserState,
+      scheme,
+    };
+  }
+
+  /**
+   * Invalidate cache for a document.
+   * @param {string} uri - Document URI
+   */
+  invalidate(uri) {
+    this.cache.delete(uri);
+  }
+
+  /**
+   * Clear all cached documents.
+   */
+  clear() {
+    this.cache.clear();
+  }
+}
+
+export const documentCache = new DocumentCache();

package/debug.js

@@ -0,0 +1,18 @@
+/* global process */
+/**
+ * Debug logging utility.
+ * Set XS_DEBUG=1 environment variable to enable debug logging.
+ */
+const isDebug = process.env.XS_DEBUG === "1";
+
+export function debugLog(...args) {
+  if (isDebug) {
+    console.log(...args);
+  }
+}
+
+export function debugError(...args) {
+  if (isDebug) {
+    console.error(...args);
+  }
+}

package/lexer/tokens.js

@@ -447,80 +447,91 @@ const tokenMappers = [
   mapZipTokenToType,
 ];
 
-/**
- * Map a token to a type (e.g., keyword, variable, etc.)
- * @param {import('chevrotain').TokenType} token
- * @returns string | null | undefined The type of the token
- */
-export function mapTokenToType(token) {
-  // Check if the token is a keyword
-  for (const mapper of tokenMappers) {
-    const type = mapper(token);
-    if (type) {
-      return type;
-    }
-  }
-
-  switch (token) {
-    // Structural and control keywords (e.g., query blocks, conditionals)
-    case Cachetoken.name:
-    case HistoryToken.name:
-    case IndexToken.name:
-    case InputToken.name:
-    case MiddlewareToken.name:
-    case MockToken.name:
-    case ResponseToken.name:
-    case ViewToken.name:
-    case SchemaToken.name:
-    case SecurityToken.name:
-    case StackToken.name:
-    case TestToken.name:
-    case FiltersToken.name:
-      return "keyword";
-
-    case DbLinkToken.name:
-      return "function";
+// Pre-built token type map for O(1) lookups
+const tokenTypeMap = new Map();
+
+// Build the map at module initialization time
+function buildTokenTypeMap() {
+  // Add local token mappings first
+  const localMappings = {
+    // Structural and control keywords
+    [Cachetoken.name]: "keyword",
+    [HistoryToken.name]: "keyword",
+    [IndexToken.name]: "keyword",
+    [InputToken.name]: "keyword",
+    [MiddlewareToken.name]: "keyword",
+    [MockToken.name]: "keyword",
+    [ResponseToken.name]: "keyword",
+    [ViewToken.name]: "keyword",
+    [SchemaToken.name]: "keyword",
+    [SecurityToken.name]: "keyword",
+    [StackToken.name]: "keyword",
+    [TestToken.name]: "keyword",
+    [FiltersToken.name]: "keyword",
+
+    [DbLinkToken.name]: "function",
 
     // Variable-related tokens
-    case AuthToken.name:
-    case DbIdentifier.name:
-    case DbReturnAggregateToken.name:
-    case DescriptionToken.name:
-    case DisabledToken.name:
-    case DocsToken.name:
-    case FieldToken.name: // field is also used as variable name in index definitio.namen
-    case GuidToken.name:
-    case SensitiveToken.name:
-    case TagsToken.name:
-    case TypeToken.name: // type is used as a variable name in index definitio.namen
-    case ValueToken.name:
-    case ValuesToken.name:
-      return "variable";
-
-    case Identifier.name:
-      return "property";
-
-    case FalseToken.name:
-    case NowToken.name:
-    case NullToken.name:
-    case TrueToken.name:
-      return "enumMember";
-
-    case DotToken.name:
-      return "punctuation";
-
-    case RegExpToken.name:
-      return "regexp";
-
-    case JsonInToken.name:
-      return "operator";
+    [AuthToken.name]: "variable",
+    [DbIdentifier.name]: "variable",
+    [DbReturnAggregateToken.name]: "variable",
+    [DescriptionToken.name]: "variable",
+    [DisabledToken.name]: "variable",
+    [DocsToken.name]: "variable",
+    [FieldToken.name]: "variable",
+    [GuidToken.name]: "variable",
+    [SensitiveToken.name]: "variable",
+    [TagsToken.name]: "variable",
+    [TypeToken.name]: "variable",
+    [ValueToken.name]: "variable",
+    [ValuesToken.name]: "variable",
+
+    [Identifier.name]: "property",
+
+    [FalseToken.name]: "enumMember",
+    [NowToken.name]: "enumMember",
+    [NullToken.name]: "enumMember",
+    [TrueToken.name]: "enumMember",
+
+    [DotToken.name]: "punctuation",
+    [RegExpToken.name]: "regexp",
+    [JsonInToken.name]: "operator",
 
     // Skip whitespace and newlines
-    case NewlineToken.name:
-    case WhiteSpace.name:
-      return null;
+    [NewlineToken.name]: null,
+    [WhiteSpace.name]: null,
+  };
+
+  for (const [tokenName, type] of Object.entries(localMappings)) {
+    tokenTypeMap.set(tokenName, type);
+  }
+
+  // Iterate through all tokens and populate the map using the mappers
+  for (const token of allTokens) {
+    if (tokenTypeMap.has(token.name)) continue;
 
-    default:
-      return undefined; // Skip unmapped or unknown tokens
+    for (const mapper of tokenMappers) {
+      const type = mapper(token.name);
+      if (type) {
+        tokenTypeMap.set(token.name, type);
+        break;
+      }
+    }
+  }
+}
+
+// Initialize the map at module load
+buildTokenTypeMap();
+
+/**
+ * Map a token to a type (e.g., keyword, variable, etc.)
+ * Uses pre-built map for O(1) lookup instead of O(n) iteration.
+ * @param {string} token - Token name
+ * @returns {string | null | undefined} The type of the token
+ */
+export function mapTokenToType(token) {
+  if (tokenTypeMap.has(token)) {
+    return tokenTypeMap.get(token);
   }
+  return undefined; // Skip unmapped or unknown tokens
 }

package/onCompletion/contentAssist.js

@@ -109,22 +109,23 @@ function isAfterPipeToken(tokens) {
   return lastToken.tokenType === PipeToken;
 }
 
-function createFilterSuggestions() {
-  return filterNames.map((filterName) => {
+// Pre-computed filter suggestions - frozen to prevent accidental mutations
+const filterSuggestions = Object.freeze(
+  filterNames.map((filterName) => {
     const documentation = filterMessageProvider.__filterDoc[filterName];
 
-    return {
+    return Object.freeze({
       label: filterName,
       kind: encodeTokenType("function"), // Filters are function-like
       documentation: documentation
-        ? {
+        ? Object.freeze({
             kind: "markdown",
             value: documentation,
-          }
+          })
         : undefined,
-    };
-  });
-}
+    });
+  })
+);
 
 export function getContentAssistSuggestions(text, scheme) {
   try {
@@ -134,7 +135,7 @@ export function getContentAssistSuggestions(text, scheme) {
 
     // Check if we're after a pipe token - if so, suggest filters
     if (isAfterPipeToken(partialTokenVector)) {
-      return createFilterSuggestions();
+      return filterSuggestions;
     }
 
     let syntacticSuggestions;

package/onDidChangeContent/onDidChangeContent.js

@@ -1,5 +1,55 @@
-import { xanoscriptParser } from "../parser/parser";
-import { getSchemeFromContent } from "../utils";
+import { documentCache } from "../cache/documentCache.js";
+import { debugError, debugLog } from "../debug.js";
+
+// Diagnostic severity constants
+const SEVERITY = {
+  ERROR: 1,
+  WARNING: 2,
+  INFORMATION: 3,
+  HINT: 4,
+};
+
+/**
+ * Creates diagnostics from parser results in a single pass.
+ * @param {Object} parser - The parser with errors, warnings, informations, hints
+ * @param {Object} document - The text document for position conversion
+ * @returns {Array} Array of diagnostic objects
+ */
+function createDiagnostics(parser, document) {
+  const diagnostics = [];
+  const defaultRange = {
+    start: { line: 0, character: 0 },
+    end: { line: 0, character: 1 },
+  };
+
+  const addDiagnostic = (item, severity) => {
+    diagnostics.push({
+      severity,
+      range: item.token
+        ? {
+            start: document.positionAt(item.token.startOffset),
+            end: document.positionAt(item.token.endOffset + 1),
+          }
+        : defaultRange,
+      message: item.message,
+    });
+  };
+
+  for (const error of parser.errors) {
+    addDiagnostic(error, SEVERITY.ERROR);
+  }
+  for (const warning of parser.warnings) {
+    addDiagnostic(warning, SEVERITY.WARNING);
+  }
+  for (const info of parser.informations) {
+    addDiagnostic(info, SEVERITY.INFORMATION);
+  }
+  for (const hint of parser.hints) {
+    addDiagnostic(hint, SEVERITY.HINT);
+  }
+
+  return diagnostics;
+}
 
 /**
  *
@@ -11,7 +61,7 @@ export function onDidChangeContent(params, connection) {
   const document = params.document;
 
   if (!document) {
-    console.error(
+    debugError(
       "onDidChangeContent(): Document not found for URI:",
       params.textDocument.uri
     );
@@ -20,96 +70,36 @@ export function onDidChangeContent(params, connection) {
 
   const text = document.getText();
 
-  const scheme = getSchemeFromContent(text);
-
   try {
-    // Parse the XanoScript file
-    const parser = xanoscriptParser(text, scheme);
+    // Parse the XanoScript file using cache
+    const { parser, scheme } = documentCache.getOrParse(
+      document.uri,
+      document.version,
+      text
+    );
 
-    if (parser.errors.length > 0) {
-      // If parsing succeeds, send an empty diagnostics array (no errors)
+    if (parser.errors.length === 0) {
+      // If parsing succeeds with no errors, send an empty diagnostics array
       connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
     }
 
     for (const error of parser.errors) {
-      console.error(
+      debugError(
         `onDidChangeContent(): Error parsing document: ${error.name}`
       );
     }
 
-    // If parsing fails, create a diagnostic (error message) to display in VS Code
-    const errors = parser.errors.map((error) => {
-      return {
-        severity: 1,
-        range: error.token
-          ? {
-              start: document.positionAt(error.token.startOffset),
-              end: document.positionAt(error.token.endOffset + 1),
-            }
-          : {
-              start: { line: 0, character: 0 },
-              end: { line: 0, character: 1 },
-            },
-        message: error.message,
-      };
-    });
-
-    const warnings = parser.warnings.map((warning) => {
-      return {
-        severity: 2,
-        range: warning.token
-          ? {
-              start: document.positionAt(warning.token.startOffset),
-              end: document.positionAt(warning.token.endOffset + 1),
-            }
-          : {
-              start: { line: 0, character: 0 },
-              end: { line: 0, character: 1 },
-            },
-        message: warning.message,
-      };
-    });
-
-    const informations = parser.informations.map((info) => {
-      return {
-        severity: 3,
-        range: info.token
-          ? {
-              start: document.positionAt(info.token.startOffset),
-              end: document.positionAt(info.token.endOffset + 1),
-            }
-          : {
-              start: { line: 0, character: 0 },
-              end: { line: 0, character: 1 },
-            },
-        message: info.message,
-      };
-    });
-
-    const hints = parser.hints.map((hint) => {
-      return {
-        severity: 4,
-        range: hint.token
-          ? {
-              start: document.positionAt(hint.token.startOffset),
-              end: document.positionAt(hint.token.endOffset + 1),
-            }
-          : {
-              start: { line: 0, character: 0 },
-              end: { line: 0, character: 1 },
-            },
-        message: hint.message,
-      };
-    });
+    // Create diagnostics in a single pass
+    const diagnostics = createDiagnostics(parser, document);
 
-    console.log(
+    debugLog(
       `onDidChangeContent(): sending diagnostic (${parser.errors.length} errors) for scheme:`,
       scheme
     );
 
     connection.sendDiagnostics({
       uri: document.uri,
-      diagnostics: [...errors, ...warnings, ...informations, ...hints],
+      diagnostics,
     });
   } catch (error) {
     // If parsing fails, create a diagnostic (error message) to display in VS Code

package/onHover/onHoverDocument.js

@@ -1,6 +1,32 @@
-import { lexDocument } from "../lexer/lexer.js";
-import { xanoscriptParser } from "../parser/parser.js";
-import { getSchemeFromContent } from "../utils.js";
+import { documentCache } from "../cache/documentCache.js";
+import { debugError } from "../debug.js";
+
+/**
+ * Binary search to find token index at the given offset.
+ * Reduces complexity from O(n) to O(log n).
+ * @param {Array} tokens - Array of tokens sorted by startOffset
+ * @param {number} offset - Cursor offset position
+ * @returns {number} Token index or -1 if not found
+ */
+function findTokenAtOffset(tokens, offset) {
+  let left = 0;
+  let right = tokens.length - 1;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const token = tokens[mid];
+
+    if (token.startOffset <= offset && token.endOffset >= offset) {
+      return mid;
+    } else if (token.endOffset < offset) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+
+  return -1;
+}
 
 /**
  *
@@ -12,7 +38,7 @@ export function onHoverDocument(params, documents, hoverProviders = []) {
   const document = documents.get(params.textDocument.uri);
 
   if (!document) {
-    console.error(
+    debugError(
       "onHover(): Document not found for URI:",
       params.textDocument.uri
     );
@@ -22,21 +48,19 @@ export function onHoverDocument(params, documents, hoverProviders = []) {
   const text = document.getText();
   const offset = document.offsetAt(params.position);
 
-  // Tokenize the document
-  const lexResult = lexDocument(text);
-  if (lexResult.errors.length > 0) return null;
+  // Get cached parse result or parse and cache
+  const { lexResult, parser } = documentCache.getOrParse(
+    params.textDocument.uri,
+    document.version,
+    text
+  );
 
-  // attempt to get the scheme from the document uri
-  const scheme = getSchemeFromContent(text);
+  if (lexResult.errors.length > 0) return null;
 
-  // Parse the XanoScript file
-  const parser = xanoscriptParser(text, scheme);
   const tokens = lexResult.tokens;
 
-  // Find the token under the cursor
-  const tokenIdx = tokens.findIndex(
-    (token) => token.startOffset <= offset && token.endOffset >= offset
-  );
+  // Find the token under the cursor using binary search (O(log n))
+  const tokenIdx = findTokenAtOffset(tokens, offset);
 
   if (tokenIdx === -1) {
     return null;

package/onSemanticCheck/highlight.js

@@ -1,3 +1,4 @@
+import { debugLog } from "../debug.js";
 import { lexDocument } from "../lexer/lexer.js";
 import { mapTokenToType } from "../lexer/tokens.js";
 import { encodeTokenType } from "./tokens.js";
@@ -33,7 +34,7 @@ function higlightDefault(text, SemanticTokensBuilder) {
         0 // No modifiers for now
       );
     } else if (tokenType === undefined) {
-      console.log(
+      debugLog(
         `token type not mapped to a type: ${JSON.stringify(
           token.tokenType.name
         )}`

package/onSemanticCheck/onSemanticCheck.js

@@ -1,3 +1,4 @@
+import { debugError } from "../debug.js";
 import { getSchemeFromContent } from "../utils";
 import { higlightText } from "./highlight";
 
@@ -11,7 +12,7 @@ export function onSemanticCheck(params, documents, SemanticTokensBuilder) {
   const document = documents.get(params.textDocument.uri);
 
   if (!document) {
-    console.error(
+    debugError(
       "onSemanticCheck(): Document not found for URI:",
       params.textDocument.uri
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.0.4",
+  "version": "11.0.6",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",
@@ -24,10 +24,8 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "chai": "^5.2.0",
     "chevrotain": "^11.0.3",
     "lodash-es": "^4.17.21",
-    "mocha": "^11.1.0",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"
   },
@@ -38,11 +36,13 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
+    "chai": "^5.2.0",
     "eslint": "^9.22.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unused-imports": "^4.2.0",
     "globals": "^16.0.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.4"
+    "lint-staged": "^16.2.4",
+    "mocha": "^11.1.0"
   }
 }

package/parser/parser.js

@@ -5,15 +5,16 @@ import { XanoBaseParser } from "./base_parser.js";
 
 /**
  * Will parse the content of the file based on its scheme (db:/, task:/, api:/...)
- * @param {string} scheme
  * @param {string} text
+ * @param {string} scheme
+ * @param {Object} [preTokenized] - Optional pre-tokenized result from lexDocument to avoid re-lexing
  * @returns
  */
-export function xanoscriptParser(text, scheme) {
+export function xanoscriptParser(text, scheme, preTokenized = null) {
   if (!scheme) {
     scheme = getSchemeFromContent(text);
   }
-  const lexResult = lexDocument(text);
+  const lexResult = preTokenized || lexDocument(text);
   parser.input = lexResult.tokens;
   switch (scheme.toLowerCase()) {
     case "addon":

package/server.js

@@ -5,6 +5,7 @@ import {
   TextDocuments,
 } from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
+import { debugLog } from "./debug.js";
 import { onCompletion } from "./onCompletion/onCompletion.js";
 import { onDidChangeContent } from "./onDidChangeContent/onDidChangeContent.js";
 import { onHover } from "./onHover/onHover.js";
@@ -50,7 +51,7 @@ documents.onDidChangeContent((params) =>
   onDidChangeContent(params, connection)
 );
 connection.onDidOpenTextDocument((params) => {
-  console.log("Document opened:", params.textDocument.uri);
+  debugLog("Document opened:", params.textDocument.uri);
   // Existing handler logic
 });