@xano/xanoscript-language-server 11.12.0 → 11.12.2

package/parser/functions/schema/schemaParseConstantFn.js

@@ -1,4 +1,5 @@
 import { isArray, some } from "lodash-es";
+import { Minus } from "../../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -37,18 +38,18 @@ export function schemaParseConstantFn($) {
             return $.CONSUME(SingleQuotedStringLiteral); // e.g., 'field instructions'
           },
         },
+
         {
           ALT: () => {
+            $.OPTION(() => $.CONSUME(Minus));
             attributeCapturedType = "number";
-            return $.CONSUME(IntegerLiteral); // e.g., 42
-          },
-        },
-        {
-          ALT: () => {
-            attributeCapturedType = "number";
-            return $.CONSUME(FloatLiteral); // e.g., 42.54
+            return $.OR1([
+              { ALT: () => $.CONSUME(IntegerLiteral) },
+              { ALT: () => $.CONSUME(FloatLiteral) },
+            ]);
           },
         },
+
         {
           ALT: () => {
             attributeCapturedType = "boolean";
@@ -76,7 +77,7 @@ export function schemaParseConstantFn($) {
       const isMatch = matchValueToSchema(
         attributeCapturedType,
         capturedValue.image,
-        schema
+        schema,
       );
 
       if (!isMatch) {
@@ -92,7 +93,7 @@ function matchValueToSchema(attributeCapturedType, value, schema) {
   // schema can be an array of type/values required
   if (isArray(schema)) {
     return some(schema, (s) =>
-      matchValueToSchema(attributeCapturedType, value, s)
+      matchValueToSchema(attributeCapturedType, value, s),
     );
   }
 
@@ -115,7 +116,7 @@ function matchValueToSchema(attributeCapturedType, value, schema) {
       return schemaValue === null;
     default:
       throw new Error(
-        `schemaParseConstantFn called with non-constant attribute: ${schema}`
+        `schemaParseConstantFn called with non-constant attribute: ${schema}`,
       );
   }
 }

package/parser/functions/varFn.js

@@ -2,9 +2,14 @@ import { DotToken } from "../../lexer/tokens.js";
 import { UpdateToken, VarToken } from "../../lexer/var.js";
 import {
   ApiBaseUrlVariable,
+  AuthVariable,
   BranchVariable,
   DatasourceVariable,
+  EnvVariable,
+  ErrorVariable,
   HttpHeadersVariable,
+  InputVariable,
+  LongFormVariable,
   RemoteHostVariable,
   RemoteIpVariable,
   RemotePasswordVariable,
@@ -53,16 +58,23 @@ export function varFn($) {
             { ALT: () => $.CONSUME(RequestUriVariable) },
             { ALT: () => $.CONSUME(TenantVariable) },
             { ALT: () => $.CONSUME(WebflowVariable) },
+            // Not recommended but still valid
+            { ALT: () => $.CONSUME(LongFormVariable) },
+            { ALT: () => $.CONSUME(EnvVariable) },
+            { ALT: () => $.CONSUME(AuthVariable) },
+            { ALT: () => $.CONSUME(InputVariable) },
+            { ALT: () => $.CONSUME(ErrorVariable) },
           ]);
+
           if (variable.image) {
             // Check for blacklisted variable names
             const nameWithoutPrefix = variable.image.startsWith("$")
               ? variable.image.slice(1)
               : variable.image;
             if (isBlacklistedVariableName(nameWithoutPrefix)) {
-              $.addInvalidValueError(
-                variable,
+              $.addWarning(
                 `'${variable.image}' is a reserved variable name and should not be used as a variable.`,
+                variable,
               );
             }
             // we can directly add the variable here but

package/parser/functions/varFn.spec.js

@@ -225,16 +225,18 @@ describe("varFn", () => {
         const parser = parse(`var $${name} {
           value = "test"
         }`);
-        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");
       });
 
       it(`rejects var.update $${name} as variable name (short form)`, () => {
         const parser = parse(`var.update $${name} {
           value = "test"
         }`);
-        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");
       });
     }
 
@@ -249,30 +251,35 @@ describe("varFn", () => {
     ];
 
     for (const name of separateTokenBlacklisted) {
-      it(`rejects var $${name} as variable name (separate token)`, () => {
+      it(`warns var $${name} as variable name (separate token)`, () => {
         const parser = parse(`var $${name} {
           value = "test"
         }`);
         if (parser.errors.length === 0) {
           console.log(parser.errors, 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");
       });
 
-      it(`rejects var.update $${name} as variable name (separate token)`, () => {
+      it(`warns var.update $${name} as variable name (separate token)`, () => {
         const parser = parse(`var.update $${name} {
           value = "test"
         }`);
-        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 $var as variable name (long form prefix)", () => {
+    it("warns var $var as variable name (long form prefix)", () => {
       const parser = parse(`var $var {
         value = "test"
       }`);
-      expect(parser.errors).to.not.be.empty;
+      expect(parser.warnings).to.not.be.empty;
+      expect(parser.errors).to.be.empty;
     });
 
     it("accepts a backtick expression as value", () => {
@@ -301,8 +308,9 @@ describe("varFn", () => {
         const parser = parse(`var.update $var.${name} {
           value = "test"
         }`);
-        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/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