@xano/xanoscript-language-server 11.12.0 → 11.12.1

package/parser/generic/asVariable.spec.js

@@ -44,8 +44,9 @@ describe("asVariable", () => {
     for (const name of shortFormBlacklisted) {
       it(`rejects as $${name} (short form)`, () => {
         const parser = parse(`as $${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -62,14 +63,16 @@ describe("asVariable", () => {
     for (const name of separateTokenBlacklisted) {
       it(`rejects as $${name} (separate token)`, () => {
         const parser = parse(`as $${name}`);
-        expect(parser.errors).to.not.be.empty;
+        expect(parser.warnings).to.not.be.empty;
       });
     }
 
     // $var is the LongFormVariable prefix, parser expects a dot after it
+    // FIXME: shoud be a warning, not an error, since it's still a valid variable name (albeit confusing)
     it("rejects as $var (long form prefix)", () => {
       const parser = parse("as $var");
-      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.not.be.empty;
     });
 
     // All blacklisted names should be rejected in long form ($var.name)
@@ -89,25 +92,26 @@ describe("asVariable", () => {
     for (const name of allBlacklisted) {
       it(`rejects as $var.${name} (long form)`, () => {
         const parser = parse(`as $var.${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
     // Ensure valid names still work
     it("accepts as $user", () => {
       const parser = parse("as $user");
-      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.be.empty;
     });
 
     it("accepts as $my_input", () => {
       const parser = parse("as $my_input");
       expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.be.empty;
     });
 
     it("accepts as $var.my_var", () => {
       const parser = parse("as $var.my_var");
-      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.be.empty;
     });
   });
 });

package/parser/generic/assignableVariableAs.js

@@ -1,6 +1,12 @@
-import { MismatchedTokenException } from "chevrotain";
 import { DotToken, Identifier } from "../../lexer/tokens.js";
-import { LongFormVariable, ShortFormVariable } from "../../lexer/variables.js";
+import {
+  AuthVariable,
+  EnvVariable,
+  ErrorVariable,
+  InputVariable,
+  LongFormVariable,
+  ShortFormVariable,
+} from "../../lexer/variables.js";
 import { isBlacklistedVariableName } from "./assignableVariableProperty.js";
 
 /**
@@ -23,10 +29,45 @@ export function assignableVariableAs($) {
       // "$var.users"
       {
         ALT: () => {
-          $.CONSUME(LongFormVariable);
-          $.CONSUME(DotToken);
-          const variable = $.CONSUME(Identifier);
-          variableName = `$${variable.image}`;
+          const variable = $.CONSUME(LongFormVariable);
+          variableName = variable.image;
+          variableToken = variable;
+
+          // Handle optional property access, e.g., "$var.users" because "$var" is a valid
+          // variable name even if it's not recommended and confusing
+          $.OPTION(() => {
+            $.CONSUME(DotToken);
+            const variable = $.CONSUME(Identifier);
+            variableName = `$${variable.image}`;
+            variableToken = variable;
+          });
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(EnvVariable);
+          variableName = variable.image;
+          variableToken = variable;
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(AuthVariable);
+          variableName = variable.image;
+          variableToken = variable;
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(InputVariable);
+          variableName = variable.image;
+          variableToken = variable;
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(ErrorVariable);
+          variableName = variable.image;
           variableToken = variable;
         },
       },
@@ -38,11 +79,9 @@ export function assignableVariableAs($) {
         ? variableName.slice(1)
         : variableName;
       if (isBlacklistedVariableName(nameWithoutPrefix)) {
-        $.SAVE_ERROR(
-          new MismatchedTokenException(
-            `'${variableName}' is a reserved variable name and cannot be used`,
-            variableToken
-          )
+        $.addWarning(
+          `'${variableToken.image}' is a reserved variable name and should not be used as a variable.`,
+          variableToken,
         );
       }
       $.addVariable(variableName, "unknown", variableToken);

package/parser/generic/assignableVariableAs.spec.js

@@ -25,6 +25,12 @@ describe("assignableVariableAs", () => {
     expect(parser.errors).to.not.be.empty;
   });
 
+  it("assignableVariableAs should warn on $var reserved variable names", () => {
+    const parser = parse("$var");
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+  });
+
   it("assignableVariableAs cannot be a short named variable with sub props", () => {
     const parser = parse("$users.x.y[1].z");
     expect(parser.errors).to.not.be.empty;
@@ -53,13 +59,28 @@ describe("assignableVariableAs", () => {
   // Blacklisted variable names - used in loop contexts (each as $variable)
   describe("blacklisted variable names", () => {
     // These are lexed as ShortFormVariable and need explicit blacklisting
-    const shortFormBlacklisted = ["output", "db", "toolset"];
+    const shortFormBlacklisted = [
+      "output",
+      "db",
+      "toolset",
+      "auth",
+      "input",
+      "env",
+      "response",
+      "output",
+      "var",
+      "db",
+      "error",
+      "toolset",
+      "this",
+    ];
 
     for (const name of shortFormBlacklisted) {
-      it(`rejects $${name} (short form)`, () => {
+      it(`warns on $${name} (short form)`, () => {
         const parser = parse(`$${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -78,10 +99,11 @@ describe("assignableVariableAs", () => {
     ];
 
     for (const name of allBlacklisted) {
-      it(`rejects $var.${name} (long form)`, () => {
+      it(`warns on $var.${name} (long form)`, () => {
         const parser = parse(`$var.${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 

package/parser/generic/assignableVariableProperty.js

@@ -1,11 +1,14 @@
-import { MismatchedTokenException } from "chevrotain";
 import { PipeToken } from "../../lexer/control.js";
 import { DotToken, Identifier, NewlineToken } from "../../lexer/tokens.js";
 import {
   ApiBaseUrlVariable,
+  AuthVariable,
   BranchVariable,
   DatasourceVariable,
+  EnvVariable,
+  ErrorVariable,
   HttpHeadersVariable,
+  InputVariable,
   LongFormVariable,
   RemoteHostVariable,
   RemoteIpVariable,
@@ -78,6 +81,11 @@ export function assignableVariableProperty($) {
               { ALT: () => $.CONSUME(RequestUriVariable) },
               { ALT: () => $.CONSUME(TenantVariable) },
               { ALT: () => $.CONSUME(WebflowVariable) },
+              // Not recommended but still valid
+              { ALT: () => $.CONSUME(EnvVariable) },
+              { ALT: () => $.CONSUME(AuthVariable) },
+              { ALT: () => $.CONSUME(InputVariable) },
+              { ALT: () => $.CONSUME(ErrorVariable) },
             ]);
             variableName = variable.image;
             variableToken = variable;
@@ -86,11 +94,17 @@ export function assignableVariableProperty($) {
         // "$var.users"
         {
           ALT: () => {
-            $.CONSUME(LongFormVariable);
-            $.CONSUME(DotToken);
-            const variable = $.CONSUME(Identifier);
-            variableName = `$${variable.image}`;
+            const variable = $.CONSUME(LongFormVariable);
+            variableName = variable.image;
             variableToken = variable;
+
+            // because we want to allow "$var" we need to optionally consume a dot and an identifier
+            $.OPTION(() => {
+              $.CONSUME(DotToken);
+              const variable = $.CONSUME(Identifier);
+              variableName = `$${variable.image}`;
+              variableToken = variable;
+            });
           },
         },
       ],
@@ -104,11 +118,9 @@ export function assignableVariableProperty($) {
         ? variableName.slice(1)
         : variableName;
       if (isBlacklistedVariableName(nameWithoutPrefix)) {
-        $.SAVE_ERROR(
-          new MismatchedTokenException(
-            `'${variableName}' is a reserved variable name and cannot be used`,
-            variableToken
-          )
+        $.addWarning(
+          `'${variableName}' is a reserved variable name and should not be used`,
+          variableToken,
         );
       }
     }

package/parser/generic/assignableVariableProperty.spec.js

@@ -30,17 +30,21 @@ describe("assignableVariableProperty", () => {
     expect(parser.errors).to.be.empty;
   });
 
-  it("assignableVariableProperty cannot be an env variable", () => {
+  it("assignableVariableProperty should warn on $env variable", () => {
     const parser = parse("$env.my_api_key");
-    expect(parser.errors).to.not.be.empty;
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+    expect(parser.warnings[0].message).to.include("reserved");
   });
 
-  it("assignableVariableProperty cannot be an input variable", () => {
+  it("assignableVariableProperty should warn on $input variable", () => {
     const parser = parse("$input.remote_ip");
-    expect(parser.errors).to.not.be.empty;
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+    expect(parser.warnings[0].message).to.include("reserved");
   });
 
-  it("assignableVariableProperty cannot be a string", () => {
+  it("assignableVariableProperty cannot be an indentifier", () => {
     const parser = parse(`"someting"`);
     expect(parser.errors).to.not.be.empty;
   });
@@ -59,8 +63,9 @@ describe("assignableVariableProperty", () => {
     for (const name of shortFormBlacklisted) {
       it(`rejects $${name} as assignable variable (short form)`, () => {
         const parser = parse(`$${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -78,14 +83,17 @@ describe("assignableVariableProperty", () => {
     for (const name of separateTokenBlacklisted) {
       it(`rejects $${name} as assignable variable (separate token)`, () => {
         const parser = parse(`$${name}`);
-        expect(parser.errors).to.not.be.empty;
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
     // $var is the LongFormVariable prefix, parser expects a dot after it
-    it("rejects $var as assignable variable (long form prefix)", () => {
+    it("warns when using $var as assignable variable (long form prefix)", () => {
       const parser = parse("$var");
-      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.not.be.empty;
     });
 
     // All blacklisted names should be rejected in long form ($var.name)
@@ -105,8 +113,9 @@ describe("assignableVariableProperty", () => {
     for (const name of allBlacklisted) {
       it(`rejects $var.${name} as assignable variable (long form)`, () => {
         const parser = parse(`$var.${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 

package/parser/generic/expressionFn.js

@@ -366,8 +366,15 @@ export function simpleExpressionFn($) {
       // Group 1: Literals (fast path - most common, distinct tokens)
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(SingleQuotedStringLiteral) },
-      { ALT: () => $.CONSUME(IntegerLiteral) },
-      { ALT: () => $.CONSUME(FloatLiteral) },
+      {
+        ALT: () => {
+          $.OPTION(() => $.CONSUME(Minus));
+          $.OR1([
+            { ALT: () => $.CONSUME(IntegerLiteral) },
+            { ALT: () => $.CONSUME(FloatLiteral) },
+          ]);
+        },
+      },
       { ALT: () => $.CONSUME(TrueToken) },
       { ALT: () => $.CONSUME(FalseToken) },
       { ALT: () => $.CONSUME(NullToken) },

package/parser/generic/expressionFn.spec.js

@@ -570,6 +570,11 @@ describe("expressionFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("expressionFn accept parenthesis for priority for math", () => {
+    const parser = parse(`(1+2+4)*5-2`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("expressionFn accept math with variable", () => {
     const parser = parse(`2 * $input.a + 2 / $input.b - 2`);
     expect(parser.errors).to.be.empty;

package/parser/generic/filterNames.js

@@ -286,6 +286,15 @@ export const filterNames = [
   "sql_esc",
   "sql_alias",
   "is_uuid",
+  "count_distinct",
+  "median",
+  "to_list",
+  "to_list_asc",
+  "to_list_desc",
+  "to_distinct_list",
+  "to_distinct_list_asc",
+  "to_distinct_list_desc",
+  "lambda",
 ];
 
 // List of input filters allowed for each input type

package/parser/multidoc.js

@@ -6,6 +6,7 @@ import { validateVariables } from "./variableValidator.js";
 
 const SEPARATOR = "\n---\n";
 const SEPARATOR_LENGTH = 5;
+const SEPARATOR_NEWLINES = 2; // number of \n characters in SEPARATOR
 
 /**
  * Find the segment that contains the given global offset.
@@ -38,6 +39,23 @@ export function findSegmentAtOffset(parserResult, offset) {
   return null;
 }
 
+/**
+ * Snapshot a Chevrotain token (or minimal token-like object) into a plain object.
+ * @param {Object|null} token
+ * @returns {Object|null}
+ */
+function snapshotToken(token) {
+  if (!token) return null;
+  return {
+    startOffset: token.startOffset,
+    endOffset: token.endOffset,
+    startLine: token.startLine,
+    startColumn: token.startColumn,
+    image: token.image,
+    tokenTypeName: token.tokenType?.name,
+  };
+}
+
 /**
  * Snapshot parser state into a plain object.
  * Must be called immediately after xanoscriptParser() before parsing next segment,
@@ -49,28 +67,22 @@ function snapshotParser(parser) {
   return {
     errors: parser.errors.map((e) => ({
       message: e.message,
-      token: e.token
-        ? { startOffset: e.token.startOffset, endOffset: e.token.endOffset }
-        : null,
+      token: snapshotToken(e.token),
+      previousToken: snapshotToken(e.previousToken),
     })),
     warnings: parser.warnings.map((w) => ({
       message: w.message,
-      token: w.token
-        ? { startOffset: w.token.startOffset, endOffset: w.token.endOffset }
-        : null,
+      token: snapshotToken(w.token),
     })),
     informations: parser.informations.map((i) => ({
       message: i.message,
-      token: i.token
-        ? { startOffset: i.token.startOffset, endOffset: i.token.endOffset }
-        : null,
+      token: snapshotToken(i.token),
     })),
     hints: parser.hints.map((h) => ({
       message: h.message,
-      token: h.token
-        ? { startOffset: h.token.startOffset, endOffset: h.token.endOffset }
-        : null,
+      token: snapshotToken(h.token),
     })),
+    sectionStack: [...parser.sectionStack],
     __symbolTable: parser.__symbolTable
       ? {
           input: { ...parser.__symbolTable.input },
@@ -94,17 +106,24 @@ function snapshotParser(parser) {
  * Apply a global offset to all position-bearing fields in a parser snapshot.
  * @param {Object} snapshot - The parser state snapshot
  * @param {number} globalOffset - The character offset to add
+ * @param {number} lineOffset - The line number offset to add
  */
-function offsetResult(snapshot, globalOffset) {
+function offsetResult(snapshot, globalOffset, lineOffset) {
   if (globalOffset === 0) return;
 
   const offsetToken = (token) => {
     if (!token) return;
     token.startOffset += globalOffset;
     token.endOffset += globalOffset;
+    if (token.startLine != null) {
+      token.startLine += lineOffset;
+    }
   };
 
-  for (const err of snapshot.errors) offsetToken(err.token);
+  for (const err of snapshot.errors) {
+    offsetToken(err.token);
+    offsetToken(err.previousToken);
+  }
   for (const warn of snapshot.warnings) offsetToken(warn.token);
   for (const info of snapshot.informations) offsetToken(info.token);
   for (const hint of snapshot.hints) offsetToken(hint.token);
@@ -161,6 +180,7 @@ export function multidocParser(text) {
   const segments = text.split(SEPARATOR);
   const results = [];
   let globalOffset = 0;
+  let lineOffset = 0;
 
   for (const segmentText of segments) {
     const parser = xanoscriptParser(segmentText);
@@ -199,8 +219,9 @@ export function multidocParser(text) {
       : null;
     // Deep-copy the snapshot before offsetResult mutates it (needed for hover providers)
     const localSnapshot = JSON.parse(JSON.stringify(snapshot));
-    results.push({ snapshot, localSnapshot, segmentText, segmentSymbolTable, globalOffset });
+    results.push({ snapshot, localSnapshot, segmentText, segmentSymbolTable, globalOffset, lineOffset });
     globalOffset += segmentText.length + SEPARATOR_LENGTH;
+    lineOffset += (segmentText.match(/\n/g) || []).length + SEPARATOR_NEWLINES;
   }
 
   // For now, merge without offsetting (next task)
@@ -221,8 +242,8 @@ export function multidocParser(text) {
     segmentCount: segments.length,
   };
 
-  for (const { snapshot, globalOffset } of results) {
-    offsetResult(snapshot, globalOffset);
+  for (const { snapshot, globalOffset, lineOffset } of results) {
+    offsetResult(snapshot, globalOffset, lineOffset);
     merged.errors.push(...snapshot.errors);
     merged.warnings.push(...snapshot.warnings);
     merged.informations.push(...snapshot.informations);

package/parser/multidoc.spec.js

@@ -299,6 +299,10 @@ function bar {
     var.update $x {
       value = 2
     }
+      
+    var $y {
+      value = 2
+    }
   }
 
   response = null
@@ -691,7 +695,9 @@ function bar {
       // The error must be within seg3's global range
       const error = result.errors[0];
       expect(error.token.startOffset).to.be.at.least(expectedSeg3Start);
-      expect(error.token.startOffset).to.be.lessThan(expectedSeg3Start + seg3.length);
+      expect(error.token.startOffset).to.be.lessThan(
+        expectedSeg3Start + seg3.length,
+      );
     });
 
     it("should isolate errors — bad seg1 should not prevent seg2 from parsing", () => {

package/parser/query_parser.js

@@ -30,6 +30,7 @@ export function queryDeclaration($) {
     let hasTags = false;
     let hasApiGroup = false;
     let hasResponseType = false;
+    let responseType = "standard";
 
     const testNames = [];
 
@@ -80,8 +81,8 @@ export function queryDeclaration($) {
             $.CONSUME(ResponseTypeToken);
             $.CONSUME8(EqualToken);
             const valueToken = $.CONSUME2(StringLiteral);
-            const value = getVarName(valueToken);
-            if (!["stream", "standard"].includes(value)) {
+            responseType = getVarName(valueToken);
+            if (!["stream", "standard"].includes(responseType)) {
               $.addInvalidValueError(
                 valueToken,
                 "response_type must be either 'stream' or 'standard'",
@@ -193,10 +194,17 @@ export function queryDeclaration($) {
       $.addMissingError(parent, "{} is missing a stack clause");
     }
 
-    if (!hasResponse) {
+    if (!hasResponse && responseType === "standard") {
       $.addMissingError(parent, "{} is missing a response clause");
     }
 
+    if (hasResponse && responseType === "stream") {
+      $.addInvalidValueError(
+        parent,
+        "response clause is not allowed when response_type is 'stream'",
+      );
+    }
+
     $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
     $.CONSUME(RCurly); // "}"
     $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line

package/parser/query_parser.spec.js

@@ -74,7 +74,6 @@ describe("query_parser", () => {
     expect(parser.errors).to.be.empty;
 
     parser = xanoscriptParser(`query foo verb=GET {
-
       response_type = "stream"
 
       input {
@@ -82,8 +81,6 @@ describe("query_parser", () => {
 
       stack {
       }
-
-      response = null
     }`);
     expect(parser.errors).to.be.empty;
   });

package/parser/tests/function/function_parser.spec.js

@@ -9,12 +9,12 @@ describe("Xanoscript Function Parser", () => {
   it("parses all the valid sources", () => {
     const errors = [];
     const files = readdirSync(
-      join(dirname("./"), "parser/tests/function/valid_sources")
+      join(dirname("./"), "parser/tests/function/valid_sources"),
     );
     files.forEach((file) => {
       const source = readFileSync(
         join(dirname("./"), "parser/tests/function/valid_sources", file),
-        "utf8"
+        "utf8",
       );
       const parser = xanoscriptParser(source);
 
@@ -26,7 +26,7 @@ describe("Xanoscript Function Parser", () => {
                   error.previousToken.image,
                   {
                     length: 20,
-                  }
+                  },
                 )})`
               : "N/A",
             file: `parser/tests/function/valid_sources/${file}:${error.token.startLine}:${error.token.startColumn}`,
@@ -36,7 +36,7 @@ describe("Xanoscript Function Parser", () => {
               error.token.image,
               {
                 length: 20,
-              }
+              },
             )})`,
           });
         });

package/parser/tests/multidoc/multidoc_parser.spec.js

@@ -0,0 +1,55 @@
+import { expect } from "chai";
+import { readdirSync, readFileSync } from "fs";
+import { truncate } from "lodash-es";
+import { describe, it } from "mocha";
+import { dirname, join } from "path";
+import { multidocParser } from "../../multidoc.js";
+
+describe("Xanoscript multidoc Parser", () => {
+  it("parses all the valid sources", () => {
+    const errors = [];
+    const files = readdirSync(
+      join(dirname("./"), "parser/tests/multidoc/valid_sources"),
+    );
+
+    files.forEach((file) => {
+      const source = readFileSync(
+        join(dirname("./"), "parser/tests/multidoc/valid_sources", file),
+        "utf8",
+      );
+      const parser = multidocParser(source);
+
+      if (parser.errors.length > 0) {
+        parser.errors.forEach((error) => {
+          errors.push({
+            previous: error.previousToken
+              ? `${error.previousToken.tokenTypeName} (${truncate(
+                  error.previousToken.image,
+                  {
+                    length: 20,
+                  },
+                )})`
+              : "N/A",
+            file: error.token
+              ? `parser/tests/multidoc/valid_sources/${file}:${error.token.startLine}:${error.token.startColumn}`
+              : `parser/tests/multidoc/valid_sources/${file}`,
+            stack:
+              parser.sectionStack?.[parser.sectionStack.length - 1] ?? "N/A",
+            message: truncate(error.message, { length: 50 }),
+            token: error.token
+              ? `${error.token.tokenTypeName} (${truncate(error.token.image, {
+                  length: 20,
+                })})`
+              : "N/A",
+          });
+        });
+      }
+    });
+
+    if (errors.length > 0) {
+      console.table(errors);
+    }
+
+    expect(errors).to.be.empty;
+  });
+});