@xano/xanoscript-language-server 12.6.0 → 12.7.0

package/onDidChangeContent/onDidChangeContent.js

@@ -1,4 +1,5 @@
 import { documentCache } from "../cache/documentCache.js";
+import { scanDbReferences } from "../parser/dbReferenceScanner.js";
 import { validateVariables } from "../parser/variableValidator.js";
 import { crossFileValidate } from "../workspace/crossFileValidator.js";
 import { workspaceIndex } from "../workspace/workspaceIndex.js";
@@ -118,8 +119,12 @@ export function onDidChangeContent(params, connection, features = {}) {
 
     // Run cross-file validation (skip for multidoc — already done internally)
     if (!parser.isMultidoc && features.crossFileValidation !== false && parser.__symbolTable?.references) {
+      // `$db.<table>.<column>` accessor chains aren't captured as references by
+      // the grammar, so scan them from the token stream and validate alongside
+      // the parser-emitted references (table + column existence).
+      const dbRefs = scanDbReferences(lexResult.tokens);
       const crossFileWarnings = crossFileValidate(
-        parser.__symbolTable.references,
+        [...parser.__symbolTable.references, ...dbRefs],
         workspaceIndex,
       );
       for (const warning of crossFileWarnings) {

package/package.json

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

package/parser/dbReferenceScanner.js

@@ -0,0 +1,70 @@
+import { Identifier } from "../lexer/identifier.js";
+import { DotToken } from "../lexer/tokens.js";
+import { ShortFormVariable } from "../lexer/variables.js";
+
+const SHORT_FORM = ShortFormVariable.name;
+const DOT = DotToken.name;
+const IDENTIFIER = Identifier.name;
+
+/**
+ * Scan the token stream for `$db.<table>.<column>` accessor chains and emit
+ * cross-file table references, so the workspace validator can check that the
+ * referenced table (and, when statically known, the column) actually exists.
+ *
+ * Emitted references match the shape consumed by {@link crossFileValidate}:
+ * `{ refType: "table", name, startOffset, endOffset }` with an optional
+ * `fieldName` (+ offsets) when the column is a plain identifier.
+ *
+ * `$`-prefixed properties (e.g. `$db.t.$search`, `$db.t.$this`) are pseudo /
+ * dynamic columns, not real columns, so only the table is validated for them.
+ *
+ * @param {import('chevrotain').IToken[]} tokens - The token stream
+ * @returns {Array<{refType: string, name: string, startOffset: number, endOffset: number, fieldName?: string, fieldNameStartOffset?: number, fieldNameEndOffset?: number}>}
+ */
+export function scanDbReferences(tokens) {
+  const references = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.tokenType.name !== SHORT_FORM || token.image !== "$db") continue;
+
+    // Expect `$db . <table>` where <table> is a plain identifier.
+    const dot = tokens[i + 1];
+    const tableToken = tokens[i + 2];
+    if (
+      !dot ||
+      dot.tokenType.name !== DOT ||
+      !tableToken ||
+      tableToken.tokenType.name !== IDENTIFIER
+    ) {
+      continue;
+    }
+
+    const ref = {
+      refType: "table",
+      name: tableToken.image,
+      startOffset: tableToken.startOffset,
+      endOffset: tableToken.endOffset,
+    };
+
+    // Optionally capture a plain-identifier column: `. <column>`.
+    const colDot = tokens[i + 3];
+    const colToken = tokens[i + 4];
+    if (
+      colDot &&
+      colDot.tokenType.name === DOT &&
+      colToken &&
+      colToken.tokenType.name === IDENTIFIER
+    ) {
+      ref.fieldName = colToken.image;
+      ref.fieldNameStartOffset = colToken.startOffset;
+      ref.fieldNameEndOffset = colToken.endOffset;
+    }
+
+    references.push(ref);
+    // Advance past the table token; the column (if any) can't start a new $db.
+    i += 2;
+  }
+
+  return references;
+}

package/parser/generic/chainedIdentifier.js

@@ -14,6 +14,12 @@ export function chainedIdentifier($) {
   };
 }
 
+/**
+ * `$` prefixed properties that are allowed without a warning, e.g.
+ * `$my_var.$search` or `$my_var.$this`.
+ */
+const ALLOWED_DOLLAR_PROPERTIES = new Set(["$search", "$this"]);
+
 /**
  * to be used after a variable to reference a single property depth
  * like foo.bar , foo[1] or foo["key"]
@@ -30,10 +36,12 @@ export function singleChainedIdentifier($) {
             {
               ALT: () => {
                 const token = $.CONSUME(ShortFormVariable);
-                $.addWarning(
-                  `Using \`$\` prefixed properties '${token.image}' is discouraged.`,
-                  token
-                );
+                if (!ALLOWED_DOLLAR_PROPERTIES.has(token.image)) {
+                  $.addWarning(
+                    `Using \`$\` prefixed properties '${token.image}' is discouraged.`,
+                    token
+                  );
+                }
               },
             }, // e.g., .bar
             { ALT: () => $.CONSUME(Identifier) }, // e.g., .bar

package/parser/multidoc.js

@@ -1,6 +1,7 @@
 import { lexDocument } from "../lexer/lexer.js";
 import { crossFileValidate } from "../workspace/crossFileValidator.js";
 import { WorkspaceIndex } from "../workspace/workspaceIndex.js";
+import { scanDbReferences } from "./dbReferenceScanner.js";
 import { xanoscriptParser } from "./parser.js";
 import { validateVariables } from "./variableValidator.js";
 
@@ -188,6 +189,15 @@ export function multidocParser(text) {
 
     // Variable validation with segment-local offsets and tokens
     const segLexResult = lexDocument(segmentText);
+
+    // Capture `$db.<table>.<column>` accessor references (segment-local offsets);
+    // offsetResult() will shift them to global coordinates like other references.
+    if (snapshot.__symbolTable?.references) {
+      snapshot.__symbolTable.references.push(
+        ...scanDbReferences(segLexResult.tokens),
+      );
+    }
+
     if (snapshot.__symbolTable?.varDeclarations) {
       const varResult = validateVariables(
         snapshot.__symbolTable,

package/parser/variableScanner.js

@@ -1,8 +1,10 @@
+import { DotToken } from "../lexer/tokens.js";
 import { LongFormVariable,ShortFormVariable } from "../lexer/variables.js";
 import { BLACKLISTED_VARIABLE_NAMES } from "./generic/assignableVariableProperty.js";
 
 const SHORT_FORM = ShortFormVariable.name;
 const LONG_FORM = LongFormVariable.name;
+const DOT = DotToken.name;
 
 const BUILTIN_NAMES = new Set(BLACKLISTED_VARIABLE_NAMES.map((n) => `$${n}`));
 // Also skip $$ (temporary variable)
@@ -31,6 +33,11 @@ export function scanVariableUsages(tokens, declarations) {
     const typeName = token.tokenType.name;
 
     if (typeName === SHORT_FORM) {
+      // Skip chained property accessors like `$db.my_table.$search`, where the
+      // `$search` token is a property name in a member-access chain, not a
+      // standalone variable reference. Such tokens are immediately preceded by
+      // a Dot token (see chainedIdentifier's singleChainedIdentifier rule).
+      if (i > 0 && tokens[i - 1].tokenType.name === DOT) continue;
       // Skip if this is a declaration site
       if (declOffsets.has(token.startOffset)) continue;
       // Skip built-in variable names