@xano/xanoscript-language-server 11.0.3

package/parser/attributes/sensitiveFieldAttribute.js

@@ -0,0 +1,17 @@
+import { EqualToken } from "../../lexer/control.js";
+import { FalseToken, SensitiveToken, TrueToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const sensitiveFieldAttribute = ($) => () => {
+  $.sectionStack.push("sensitiveFieldAttribute");
+  $.CONSUME(SensitiveToken); // "sensitive"
+  $.CONSUME(EqualToken); // "="
+  $.OR([
+    { ALT: () => $.CONSUME(TrueToken) }, // "true"
+    { ALT: () => $.CONSUME(FalseToken) }, // "false"
+  ]);
+  $.sectionStack.pop();
+};

package/parser/attributes/sensitiveFieldAttribute.spec.js

@@ -0,0 +1,39 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.sensitiveFieldAttribute();
+  return parser;
+}
+
+describe("sensitiveFieldAttribute", () => {
+  it("sensitiveFieldAttribute accepts a true value", () => {
+    const parser = parse("sensitive = true");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("sensitiveFieldAttribute accepts a true value", () => {
+    const parser = parse("sensitive = false");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("sensitiveFieldAttribute rejects anything else", () => {
+    const parser = parse("sensitive = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("sensitiveFieldAttribute rejects digit", () => {
+    const parser = parse("sensitive = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("sensitiveFieldAttribute can be compact", () => {
+    const parser = parse("sensitive=true");
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/attributes/valueFieldAttribute.js

@@ -0,0 +1,17 @@
+import { EqualToken } from "../../lexer/control.js";
+import { ValueToken } from "../../lexer/tokens.js";
+
+/**
+ * Defines a value to be an expression
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function valueFieldAttribute($) {
+  return () => {
+    $.sectionStack.push("valueFieldAttribute");
+    const parent = $.CONSUME(ValueToken); // "value"
+    $.CONSUME(EqualToken); // "="
+    // TODO: We'll likely want to also block $var references
+    $.SUBRULE($.expressionFn, { ARGS: [parent, { allowIdentifier: false }] }); // e.g., "A value of the field"
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/valueFieldAttribute.spec.js

@@ -0,0 +1,54 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.valueFieldAttribute();
+  return parser;
+}
+
+describe("valueFieldAttribute", () => {
+  it("valueFieldAttribute accepts a string literal", () => {
+    const parser = parse('value = "some value goes here"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute accepts a digit", () => {
+    const parser = parse("value = 123");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute accepts a float", () => {
+    const parser = parse("value = 12.3");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute accepts a boolean", () => {
+    const parser = parse("value = false");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute accepts a variable", () => {
+    const parser = parse("value = $variable");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute can be compact", () => {
+    const parser = parse('value="another value"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute does not require a new line", () => {
+    const parser = parse('value="some value"');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valueFieldAttribute rejects identifier", () => {
+    const parser = parse("value = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/attributes/valuesFieldAttribute.js

@@ -0,0 +1,18 @@
+import { EqualToken } from "../../lexer/control.js";
+import { ValuesToken } from "../../lexer/tokens.js";
+
+/**
+ * for value definitions like
+ *   values = ["active", "inactive", "unknown"]
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function valuesFieldAttribute($) {
+  return () => {
+    $.sectionStack.push("valuesFieldAttribute");
+    $.CONSUME(ValuesToken); // "values"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.stringArray); // List of values
+    $.sectionStack.pop();
+  };
+}

package/parser/attributes/valuesFieldAttribute.spec.js

@@ -0,0 +1,44 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.valuesFieldAttribute();
+  return parser;
+}
+
+describe("valuesFieldAttribute", () => {
+  it("valuesFieldAttribute accepts a string literal", () => {
+    const parser = parse('values = [ "some", "values" ]');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valuesFieldAttribute accepts multiple line feeds", () => {
+    const parser = parse('values = [ "some", "values" ]');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valuesFieldAttribute rejects identifier", () => {
+    const parser = parse("values = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("valuesFieldAttribute rejects digit", () => {
+    const parser = parse("values = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("valuesFieldAttribute can be compact", () => {
+    const parser = parse('values=["another","description"]');
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("valuesFieldAttribute does not requires a new line", () => {
+    const parser = parse('values = [ "some", "values" ]');
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/base_parser.js

@@ -0,0 +1,249 @@
+import {
+  defaultParserErrorProvider,
+  MismatchedTokenException,
+} from "chevrotain";
+import { CstParser } from "chevrotain";
+import { isArray } from "lodash-es";
+import { register } from "./register.js";
+
+// ----------------- Custom Error Provider ------------
+const XanoCustomErrorProvider = {
+  // buildMismatchTokenMessage: (options) =>
+  //   `'${options.expected.name}' expected (${options.ruleName})`,
+  buildMismatchTokenMessage:
+    defaultParserErrorProvider.buildMismatchTokenMessage,
+  buildEarlyExitMessage: defaultParserErrorProvider.buildEarlyExitMessage,
+
+  buildNotAllInputParsedMessage:
+    defaultParserErrorProvider.buildNotAllInputParsedMessage,
+
+  buildNoViableAltMessage: defaultParserErrorProvider.buildNoViableAltMessage,
+};
+
+// base_parser.js
+export class XanoBaseParser extends CstParser {
+  constructor(tokenVocabulary) {
+    super(tokenVocabulary, {
+      errorMessageProvider: XanoCustomErrorProvider,
+      recoveryEnabled: false, // fail on first error found
+    });
+    register(this);
+    this.sectionStack = [];
+    this.warnings = [];
+    this.reset();
+  }
+
+  /**
+   *  @deprecated - use schemaParseAttributeFn instead
+   */
+  functionAttrReq() {}
+
+  /**
+   * Add a variable to the registry
+   * @param {string} name the name of the variable
+   * @param {string} type the type of the variable (int, decimal, text, bool, etc)
+   * @param {boolean} nullable whether the variable is nullable
+   */
+  addVariable(name, type, value = null) {
+    this.__symbolTable.var[name] = { type, value };
+  }
+
+  /**
+   * Add an input to the registry
+   * @param {string} name
+   * @param {string} type
+   * @param {boolean} nullable whether the variable is nullable
+   */
+  addInput(name, type, iterable = false, nullable = false, optional = false) {
+    this.__symbolTable.input[name] = { type, iterable, nullable, optional };
+  }
+
+  /**
+   * Add a warning message to the parser
+   * @param {*} message
+   * @param {*} token
+   */
+  addWarning(message, token) {
+    token = token || this.LA(0);
+    this.warnings.push({ message, token });
+  }
+
+  /**
+   * Add an information message to the parser
+   * @param {*} message
+   * @param {*} token
+   */
+  addInformation(message, token) {
+    token = token || this.LA(0);
+    this.informations.push({ message, token });
+  }
+
+  /**
+   * Add a hint message to the parser
+   * @param {*} message
+   * @param {*} token
+   */
+  addHint(message, token) {
+    token = token || this.LA(0);
+    this.hints.push({ message, token });
+  }
+
+  /**
+   * Add an custom error message when a token is missing
+   * @param {import('chevrotain').IToken} token
+   * @param {string} message
+   */
+  addMissingError(token, message) {
+    token = token || this.LA(0);
+
+    this.SAVE_ERROR(
+      new MismatchedTokenException(message.replaceAll("{}", token.image), token)
+    );
+  }
+
+  /**
+   * Add an error when a required attribute is missing
+   * @param {import('chevrotain').IToken} token
+   * @param {string[]} missingAttributes
+   */
+  addMissingAttributeError(token, missingAttributes) {
+    token = token || this.LA(0);
+    missingAttributes = [].concat(missingAttributes);
+    const missing = missingAttributes.join(", ");
+    const message =
+      missingAttributes.length === 1
+        ? `${token.image} is missing the ${missing} attribute`
+        : `${token.image} is missing the following attributes: ${missing}`;
+    this.SAVE_ERROR(new MismatchedTokenException(message, token));
+  }
+
+  /**
+   * Add an error when an attribute is not allowed
+   * @param {import('chevrotain').IToken} token
+   * @param {string} message (optional) the error message
+   */
+  addIllegalAttributeError(token, message) {
+    token = token || this.LA(0);
+    if (!message) {
+      message = `Attribute \`${token.image}\` is not allowed`;
+    }
+    this.SAVE_ERROR(new MismatchedTokenException(message, token));
+  }
+
+  /**
+   * Add an error when an attribute type is not as expected
+   * @param {import('chevrotain').IToken} token
+   */
+  addExpectedValueTypeError(token, expectedType) {
+    token = token || this.LA(0);
+    this.SAVE_ERROR(
+      new MismatchedTokenException(
+        `Expected value of \`${token.image}\` to be of type \`${expectedType}\``,
+        token
+      )
+    );
+  }
+
+  /**
+   * Add an error when an attribute value is not as expected
+   * @param {import('chevrotain').IToken} token
+   */
+  addExpectedValueError(token, expectedType) {
+    token = token || this.LA(0);
+    if (isArray(expectedType) && expectedType.length > 1) {
+      this.SAVE_ERROR(
+        new MismatchedTokenException(
+          `Expected value of \`${token.image}\` to be one of ${expectedType
+            .map((t) => `\`${t}\``)
+            .join(", ")}`,
+          token
+        )
+      );
+    } else {
+      this.SAVE_ERROR(
+        new MismatchedTokenException(
+          `Expected value of \`${token.image}\` to be \`${expectedType}\``,
+          token
+        )
+      );
+    }
+  }
+
+  /**
+   * Add an error when an attribute is duplicated
+   * @param {import('chevrotain').IToken} token
+   */
+  addDuplicateAttributeError(token) {
+    token = token || this.LA(0);
+    this.SAVE_ERROR(
+      new MismatchedTokenException(
+        `Duplicate attribute \`${token.image}\``,
+        token
+      )
+    );
+  }
+
+  /**
+   * Add an error when a name is duplicated
+   * @param {import('chevrotain').IToken} token
+   * @param {string} objectType the type of object (e.g., function, table, test, etc.)
+   */
+  addDuplicateNameError(token, objectType) {
+    token = token || this.LA(0);
+    if (objectType) {
+      this.SAVE_ERROR(
+        new MismatchedTokenException(
+          `Duplicate ${objectType} name '${token.image}'`,
+          token
+        )
+      );
+    } else {
+      this.SAVE_ERROR(
+        new MismatchedTokenException(`Duplicate name '${token.image}'`, token)
+      );
+    }
+  }
+
+  /**
+   * Add an error for invalid values
+   * @param {import('chevrotain').IToken} token
+   * @param {string} message the error message
+   */
+  addInvalidValueError(token, message) {
+    token = token || this.LA(0);
+    this.SAVE_ERROR(new MismatchedTokenException(message, token));
+  }
+
+  /**
+   * Setup all the required rules for the parser but without creating duplicates
+   *
+   * @param {function[]} ruleFn rule is a function that returns a rule definition
+   */
+  requireRules(...ruleFn) {
+    for (const fn of ruleFn) {
+      if (typeof fn !== "function") {
+        throw new Error(
+          `requireRules only accepts functions, ${typeof fn} given`
+        );
+      }
+
+      if (!Object.hasOwn(this, fn.name)) {
+        this[fn.name] = this.RULE(fn.name, fn(this));
+      }
+    }
+  }
+
+  reset() {
+    super.reset();
+    this.sectionStack = [];
+    this.warnings = [];
+    this.informations = [];
+    this.hints = [];
+    this.__symbolTable = {
+      input: {},
+      var: {},
+      auth: {},
+      env: {},
+    };
+  }
+}

package/parser/branch_parser.js

@@ -0,0 +1,49 @@
+import { BranchToken } from "../lexer/branch.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function branchDeclaration($) {
+  return () => {
+    $.sectionStack.push("branchDeclaration");
+    // Allow leading comments and newlines before the branch declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(BranchToken); // branch
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+
+    const middlewareSchema = {
+      pre: [{ name: "[string]" }],
+      post: [{ name: "[string]" }],
+    };
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
+        {
+          color: "[string]",
+          "description?": "[string]",
+          middleware: {
+            function: middlewareSchema,
+            query: middlewareSchema,
+            task: middlewareSchema,
+            tool: middlewareSchema,
+          },
+          history: {
+            function: [false, 10, 100, 1000, 10000, "all"],
+            query: [false, 10, 100, 1000, 10000, "all"],
+            task: [false, 10, 100, 1000, 10000, "all"],
+            tool: [false, 10, 100, 1000, 10000, "all"],
+            trigger: [false, 10, 100, 1000, 10000, "all"],
+            middleware: [false, 10, 100, 1000, 10000, "all"],
+          },
+        },
+      ],
+    });
+
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/branch_parser.spec.js

@@ -0,0 +1,34 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("branch_parser", () => {
+  it("should parse a complete branch with identifier", () => {
+    const parser = xanoscriptParser(`// This is the original branch.
+  branch v1 {
+    color = "#fff3cd"
+    middleware = {
+      function: {pre: [{name: "test middleware 2"}], post: []}
+      query   : {
+        pre : [{name: "test middleware 1"}]
+        post: [{name: "test middleware 2"}]
+      }
+      task    : {
+        pre : [{name: "test middleware 2"}]
+        post: [{name: "test middleware 1"}]
+      }
+      tool    : {pre: [], post: [{name: "test middleware 2"}]}
+    }
+  
+    history = {
+      function  : false
+      query     : 100
+      task      : 100
+      tool      : 100
+      trigger   : false
+      middleware: false
+    }
+  }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/agentClause.js

@@ -0,0 +1,23 @@
+import { AgentToken } from "../../lexer/columns.js";
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const agentClause = ($) => () => {
+  $.sectionStack.push("agentClause");
+
+  const parent = $.CONSUME(AgentToken); // agent
+  $.CONSUME(EqualToken); // =
+
+  const result = $.CONSUME(StringLiteral); // "agentname"
+
+  // Don't allow empty values inside quotes
+  if (result.image === `""`) {
+    $.addMissingError(parent, "agent cannot be empty");
+  }
+
+  $.sectionStack.pop();
+};

package/parser/clauses/agentClause.spec.js

@@ -0,0 +1,34 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.agentClause();
+  return parser;
+}
+
+describe("agentClause", () => {
+  it("agentClause accepts string", () => {
+    const parser = parse(`agent = "test"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("agentClause doesn't allow empty string with double quotes", () => {
+    const parser = parse(`agent = ""`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("agentClause doesn't allow empty string with single quotes", () => {
+    const parser = parse(`agent = ''`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("agentClause only allows strings (not numerical)", () => {
+    const parser = parse(`agent = '123'`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/authClause.js

@@ -0,0 +1,17 @@
+import { EqualToken } from "../../lexer/control.js";
+import { AuthToken, FalseToken, TrueToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const authClause = ($) => () => {
+  $.sectionStack.push("authClause");
+  $.CONSUME(AuthToken); // "auth"
+  $.CONSUME(EqualToken); // "="
+  $.OR([
+    { ALT: () => $.CONSUME(TrueToken) }, // "true"
+    { ALT: () => $.CONSUME(FalseToken) }, // "false"
+  ]);
+  $.sectionStack.pop();
+};

package/parser/clauses/authClause.spec.js

@@ -0,0 +1,39 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.authClause();
+  return parser;
+}
+
+describe("authClause", () => {
+  it("authClause accepts a true value", () => {
+    const parser = parse("auth = true");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("authClause accepts a true value", () => {
+    const parser = parse("auth = false");
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("authClause rejects anything else", () => {
+    const parser = parse("auth = something");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("authClause rejects digit", () => {
+    const parser = parse("auth = 123");
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("authClause can be compact", () => {
+    const parser = parse("auth=true");
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/cacheClause.js

@@ -0,0 +1,32 @@
+import { EqualToken } from "../../lexer/control.js";
+import { Cachetoken } from "../../lexer/tokens.js";
+
+/**
+ * sets the cache for the query or function
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function cacheClause($) {
+  return () => {
+    $.sectionStack.push("cacheClause");
+    const parent = $.CONSUME(Cachetoken); // "cache"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.objectAttrReq, {
+      ARGS: [
+        parent,
+        ["ttl", "input", "auth", "datasource", "ip"],
+        ["headers", "env"],
+        {
+          types: {
+            ttl: "number",
+            input: "boolean",
+            auth: "boolean",
+            datasource: "boolean",
+            ip: "boolean",
+          },
+        },
+      ],
+    });
+
+    $.sectionStack.pop();
+  };
+}